# Hugging Face AI Org Lead Extractor (`ayeeyee/huggingface-ai-org-lead-extractor`) Actor

Turn Hugging Face keywords or org slugs into AI-company sales leads: a verified contact email/phone/social from the org's OWN company website, tech stack, an A-D lead score, and a trending-org signal. Orgs only, never individuals. No API keys, no proxy. Per-successful-result pricing.

- **URL**: https://apify.com/ayeeyee/huggingface-ai-org-lead-extractor.md
- **Developed by:** [Virtual Footprint LLC](https://apify.com/ayeeyee) (community)
- **Categories:** Lead generation, Business, Marketing
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 verified ai-org leads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Hugging Face AI Org Lead Extractor

Turn Hugging Face model authors into ready-to-pitch **AI-company sales leads**.

For each AI org, this Actor discovers models via Hugging Face's public keyless
[Hub API](https://huggingface.co/docs/huggingface/en/api), confirms the namespace
is an **organization** (not an individual — a ToS-safe gate), discovers the org's
**own company website** (via its HF org page + the top model's model-card README),
and enriches that site with the same MX/DNS-verified email + phone + social +
tech-stack + A–D lead-score layer used across the API Factory lead-extractors.
Each lead also carries org firmographics (followers, model count, verified badge)
and a **trending/growing-AI-org signal** (HF traction + publishing recency +
contactability → A–D grade).

No HF author personal emails are mined (that is the ToS-gray personal-data harvest
we reject). The contact always comes from the AI org's **own** company website.

> No API keys. No residential proxy. No compose cost. Works straight out of the
> box — Hugging Face's Hub API is public and keyless, and we fetch each org's own
> public company site directly. Margin-positive from day one.

***

### Use cases

- **B2B vendor prospecting** — find AI orgs in a space you sell into (GPU/cloud,
  eval, inference, observability, data, dev-tool, MLOps vendors) with a verified
  contact on their own company site.
- **Investor / partnership outreach** — surface trending/growing AI orgs (high HF
  followers + recent model publishes + reachable contact) before they're widely
  known.
- **Monitoring / "newly published since last run"** — schedule with `sinceDays`
  to get only AI orgs that published a model in the trailing N days.

### How it works

1. **Discover** models via `huggingface.co/api/models?search=…&sort=likes` (or
   `pipeline_tag=` for known HF tasks like `text-generation`), newest-first when
   a recency filter is set. Models are rolled up to **one lead per org
   namespace** (the slug before `/`).
2. **Org gate (ToS-safe)** — `/api/organizations/{ns}/overview` returns `200` for
   an organization and `404` for an individual user. Only org namespaces are
   kept; individuals are skipped (never mined). The overview also yields
   firmographics (fullname, `isVerified`, `numModels`, `numFollowers`,
   `numPapers`).
3. **Company-website hop** — the org's declared external link on its HF org page
   is the authoritative company website (e.g. `mistral.ai`, `bfl.ai`,
   `deepseek.com`). If the org page has no external site, the model-card README
   is scanned and a link is trusted only if its apex domain matches the org
   namespace — so a third-party paper/blog/license site is never misattributed.
4. **Enrich** the company website with MX/DNS-verified emails, phones, socials,
   tech stack, and an A–D lead score (shared `enrich.py` layer).
5. **Bill** only per AI-org lead that returns a real contact signal — empty /
   no-contact orgs are returned honestly and never billed.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | string\[] | `["text-generation"]` | Keywords or HF pipeline tags (e.g. `text-generation`, `text-to-image`, `AI agent`). Pipeline tags use the exact task filter (surfaces real orgs by traction); freeform keywords use full-text search. |
| `orgSlugs` | string\[] | `[]` | Explicit HF org namespace slugs to enrich directly (e.g. `mistralai`), bypassing keyword search. |
| `maxPerQuery` | int | `20` | Cap on models per query (1–100); these roll up to one lead per org. |
| `sinceDays` | int | `0` | Keep only models published in the trailing N days. `0` = all time. Monitoring mode (sorts newest-first). |
| `minLikes` | int | `0` | Minimum HF likes on the org's representative model (community traction). |
| `verifyEmails` | bool | `true` | MX/DNS-validate the best contact email's domain. |
| `enrichWebsite` | bool | `true` | Discover the org's company site + extract emails/phones/socials/tech. Disable for metadata-only runs (no contact data, nothing billed). |
| `concurrency` | int | `5` | Parallel orgs enriched (1–10). |
| `proxyConfiguration` | object | `{}` | Optional — only if you hit rate limits. |

Provide `searchQueries` and/or `orgSlugs`. A typical run takes ~20–40s for
\~20 orgs at the default concurrency.

### Output

One dataset item per AI org (organizations only; individuals are not emitted as
billed leads):

```json
{
  "namespace": "deepseek-ai",
  "modelSlug": "DeepSeek-R1",
  "modelUrl": "https://huggingface.co/deepseek-ai/DeepSeek-R1",
  "pipelineTag": "text-generation",
  "downloads": 8739585,
  "likes": 13461,
  "modelCount": 5,
  "newestModelDate": "2026-04-22T06:04:45+00:00",
  "orgUrl": "https://huggingface.co/deepseek-ai",
  "isOrg": true,
  "orgFullname": "DeepSeek",
  "isVerified": true,
  "numFollowers": 137393,
  "numModels": 101,
  "numPapers": 27,
  "companyUrl": "https://www.deepseek.com/",
  "emails": ["service@deepseek.com", "security@deepseek.com"],
  "emailVerified": true,
  "phones": [],
  "socials": { "twitter": "https://twitter.com/deepseek_ai" },
  "techStack": ["React"],
  "orgReadiness": "A",
  "orgLabel": "Prime trending AI-org target — strong HF traction, recently publishing, reachable contact.",
  "leadScore": "A",
  "hasContact": true
}
```

> The sample above is a real lead from a live run (`searchQueries: ["text-generation"]`, 2026-07-13) — not fabricated. Fields that have no public
> value return `[]` / `null` honestly (e.g. `phones: []` here) rather than
> placeholder data.

#### Field reference

| Field | Meaning |
|---|---|
| `namespace` | The HF org slug (`mistralai`, `deepseek-ai`). One lead per org. |
| `isOrg` | `true` if the overview endpoint confirmed an organization; `false` = individual (skipped, not billed). |
| `orgFullname` / `isVerified` / `numFollowers` / `numModels` / `numPapers` | Org firmographics from the HF overview. |
| `modelSlug` / `modelUrl` / `pipelineTag` / `downloads` / `likes` | The org's representative (highest-likes) matching model. |
| `companyUrl` | The org's own company website (discovered, trusted). `null` if none found. |
| `emails` / `emailVerified` | MX/DNS-verified business contact emails from the org's own site. |
| `socials` / `techStack` | Social profiles + detected tech stack from the org's own site. |
| `orgReadiness` / `orgLabel` | A–D trending-org grade (followers + model traction + publishing recency + contactability). |
| `leadScore` | A–D signal-richness grade (email+verified+phone+social+tech). |
| `hasContact` | `true` if any contact signal was found — the billable event. |

### Pricing (pay-per-event)

You are charged only for **successful** results — never for empty/no-contact
runs (the #1 market complaint about flat-rate metadata-dump scrapers).

| Event | Price | When charged |
|---|---|---|
| Actor Start | $0.0001 | Once per run start. |
| **Verified AI-Org Lead** (primary) | **$0.008** | Once per AI org that returns ≥1 real contact signal. |
| Verified Org Email | $0.003 | When an org yields ≥1 MX/DNS-validated email. |
| Trending-Org Signal | $0.001 | When the A–D org-readiness grade is computed. |

A typical billed lead (verified email + readiness grade) costs ~$0.012. With
zero upstream compose cost (keyless HF API + direct fetch of the org's own
site), each result is margin-positive from the first run.

### Performance & limits

- \~20–40s for 20 orgs at default concurrency on Apify.
- The HF Hub API is keyless and generous; a proxy is rarely needed. If you hit
  rate limits on very large sweeps, set `proxyConfiguration`.
- Some orgs (research groups, e.g. `bigscience`) have no public company website
  on their HF page — these return `companyUrl: null` and `hasContact: false`
  and are **not billed** (honest no-contact, not a fabricated lead).

### Troubleshooting

- **An org I expected is missing** — it may be an individual user namespace
  (`isOrg: false`, skipped per the ToS-safe gate) or it had no matching model
  in the top `maxPerQuery` results. Raise `maxPerQuery` or pass it directly via
  `orgSlugs`.
- **`companyUrl` is `null`** — the org's HF page and model-card README exposed
  no external company site, or only third-party/paper links that failed the
  name-match trust check. The org degrades to metadata-only and is not billed.
- **`emails` is `[]` but `hasContact` is `true`** — the org's site had socials
  (or phones) but no public email; that still counts as a reachable contact.
- **Want faster, metadata-only runs** — set `enrichWebsite: false` (no contact
  data, nothing billed; returns org firmographics + model metadata only).

### Data sources & compliance

- Hugging Face public Hub API (`/api/models`, `/api/organizations/{ns}/overview`)
  — keyless, no anti-bot.
- Each AI org's own public company website — fetched directly (no platform pages:
  GitHub/Twitter/etc. are skipped via the shared platform-host gate).
- No HF author/individual personal data is mined; contact is always sourced from
  the organization's own website.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords or HF pipeline tags to discover AI models via Hugging Face's keyless Hub API (e.g. 'text-generation', 'text-to-image', 'AI agent'). Matching models are rolled up to one lead per organization namespace.

## `orgSlugs` (type: `array`):

Hugging Face organization namespace slugs to enrich directly (e.g. 'mistralai', 'qwenlm'), bypassing keyword search. Useful for enriching a known list of AI orgs.

## `maxPerQuery` (type: `integer`):

Cap on models returned per keyword query (1-100); these roll up to one lead per org namespace.

## `sinceDays` (type: `integer`):

Keep only models created within the trailing N days. 0 = no recency filter. Use this for the 'newly published since last run' monitoring mode (sorts newest-first).

## `minLikes` (type: `integer`):

Keep only orgs whose representative model has at least this many HF likes (community traction). 0 = no minimum.

## `verifyEmails` (type: `boolean`):

Validate the best contact email's domain against live MX/DNS records.

## `enrichWebsite` (type: `boolean`):

Discover the org's own company website (via its HF page + top model's model-card README) and extract emails/phones/socials/tech stack. Disable for faster, metadata-only runs (no contact data, nothing billed).

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

AI orgs enriched in parallel (1-10).

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

Optional. Only needed if you hit rate limits; the Actor works without a proxy (Hugging Face's keyless Hub API + the orgs' own public company websites).

## Actor input object example

```json
{
  "searchQueries": [
    "text-generation",
    "text-to-image"
  ],
  "orgSlugs": [
    "mistralai",
    "deepseek-ai"
  ],
  "maxPerQuery": 20,
  "sinceDays": 0,
  "minLikes": 0,
  "verifyEmails": true,
  "enrichWebsite": true,
  "concurrency": 5,
  "proxyConfiguration": {}
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQueries": [
        "text-generation"
    ],
    "orgSlugs": [],
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("ayeeyee/huggingface-ai-org-lead-extractor").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 = {
    "searchQueries": ["text-generation"],
    "orgSlugs": [],
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("ayeeyee/huggingface-ai-org-lead-extractor").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 '{
  "searchQueries": [
    "text-generation"
  ],
  "orgSlugs": [],
  "proxyConfiguration": {}
}' |
apify call ayeeyee/huggingface-ai-org-lead-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ayeeyee/huggingface-ai-org-lead-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/4XsgQ3vyqrxiBApvZ/builds/VRo41hgMM7RjGRwlK/openapi.json