# Hugging Face Profile Email Scraper (`neuro-scraper/hugging-face-profile-email-scraper`) Actor

Hugging Face Profile Email Scraper SD - Hugging Face Profile Email Scraper is a lead generation tool that extracts leads with public contact emails, bio, follower counts and profile URLs from Hugging Face profile URLs or usernames - Hugging Face profile scraper for creator outreach.

- **URL**: https://apify.com/neuro-scraper/hugging-face-profile-email-scraper.md
- **Developed by:** [Neuro Scraper](https://apify.com/neuro-scraper) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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/actors/running/actors-in-store.md#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 Profile Email Scraper

Hugging Face Profile Email Scraper builds a clean contact table two ways. Give it **keywords** and it harvests Hub accounts that publish a contact address; give it **profile URLs or usernames** for accounts you already have.

A keyword run is not a word match. The Hugging Face Profile Email Scraper asks Google for indexed Hub pages carrying both your term and a published address, then fetches every account it finds for profile data and merges the two into one row.

Keywords, URLs and handles combine freely in one run, and only one of them is required. Use keywords when you have no list yet, and profile URLs or usernames when you do.

One important fact up front: **Hugging Face profiles expose a name, bio and avatar rather than follower statistics.** So `followersCount`, `followingCount`, `postsCount` and the account flags usually come back `null`, and this Hugging Face Profile Email Scraper does not pretend otherwise.

Second important fact: this Hugging Face Profile Email Scraper reads the **public profile page**, plus public search results for pages the Hub published. It never opens model cards, dataset cards, repository files, commit metadata, Spaces code, discussion threads or comments.

The Hugging Face Profile Email Scraper uses no login, no cookies, no private or official API and no browser rendering. Everything it collects is what a signed-out visitor sees.

### What the Hugging Face Profile Email Scraper does

The Hugging Face Profile Email Scraper runs in two phases, and the order is the whole design: it harvests accounts and addresses first, then fills in the profile data.

**Phase 1 — Google harvest, on the GOOGLE\_SERP proxy.** When keywords are given, the Hugging Face Profile Email Scraper searches Google with an email dork — `site:huggingface.co speech recognition "@gmail.com"` — instead of searching for the term on its own.

Each query is expanded across your keywords, the query modifiers and the address domains, and paged up to `maxPagesPerKeyword`. Each result block yields the account handle and the address published on that page in one request.

Google no longer prints the target URL on most layouts, so the handle comes from what it does print: the "Hugging Face - handle" site label, the breadcrumb, or a `Name (@handle)` title. This is where the volume and most of the addresses come from: those pages already carry the address.

**Phase 2 — profile enrichment, on the RESIDENTIAL proxy.** Every account found is then fetched for its real profile data — name, bio, avatar, external link — and merged into one row with the address from phase 1. Accounts you supplied skip phase 1 and start here.

Each target is normalised to a canonical `https://huggingface.co/{username}` URL first: a bare handle, an `@handle` and a full URL all resolve to the same target, and duplicates are dropped.

The fetch uses async HTTP with several profiles in flight, and every retry requests a fresh exit IP. The first attempt sends a full Chrome header set and a retry falls back to a plain one.

Parsing in the Hugging Face Profile Email Scraper runs as a regex-first cascade. A regex battery is run against the raw HTML first, matching field key names directly; the generic parser and Open Graph meta tags then fill only the fields the earlier step could not find.

Finally the Hugging Face Profile Email Scraper merges the harvested address with any it finds in the bio, display name and external URL, and pushes one dataset row per account immediately, saving progress as it goes.

### Finding accounts by keyword

Keyword input is a real harvest of Hub accounts, not a filter over URLs you supplied. `expandQueries` is on by default, so each keyword is also searched with the query modifiers — `email`, `contact`, `maintainer`, `author`, `support` here — and with each address domain in turn.

The harvest runs on the Apify **GOOGLE\_SERP** proxy, with `location` appended to each term when you set it and `maxPagesPerKeyword` deciding how deep each query reads. The profile fetch stays on the **RESIDENTIAL** proxy, because neither proxy group can do the other's job.

The Hugging Face Profile Email Scraper enriches every account discovered exactly like one you supplied: same canonical URL, same regex-first cascade, same row shape. Keyword search only decides **which accounts get read**.

### Why teams use this Hugging Face email finder

AI/ML talent sourcing is hard because the good candidates are not on job boards. They are model authors and dataset maintainers with a public bio and a link tree, and this Hugging Face bio email extractor reads exactly that.

Recruiters use the Hugging Face Profile Email Scraper because the Hub is a pre-selected community of ML specialists. Developer relations and dev-tool marketing teams use this Hugging Face lead generation workflow to reach maintainers whose work touches their stack.

Because the Hugging Face Profile Email Scraper only surfaces addresses people chose to publish on an indexed public page or in their own bio, it fits a respectful outreach motion.

### Key features

| Feature | What it means in practice |
|---|---|
| Google harvest | `keywords` finds accounts publishing an address, with the handle and the address in one result. |
| Profile enrichment | Every account found is then fetched for name, bio, avatar and external link. |
| Query expansion | `expandQueries` and `queryModifiers` search each keyword in several phrasings. |
| URL or handle input | `profileUrls` and `usernames` are merged, normalised and deduplicated. |
| Public page only | No login, no cookies, no private API, no browser rendering. |
| Two proxies | GOOGLE\_SERP for the harvest, RESIDENTIAL for the profile fetch. |
| Email hygiene | Obfuscated addresses are decoded, placeholders and prose words dropped. |
| Domain control | `customDomains` sets the domains the harvest asks for and filters what is kept. |
| Email-only mode | `onlyWithEmail` skips accounts with no address found. |
| Parallel fetching | `maxConcurrency` from 1 to 30 profiles and searches at a time. |
| Resumable runs | Progress is keyed to a hash of the input; a restarted run continues. |
| Retries | Up to 4 attempts per page, exponential backoff, fresh exit IP each time. |
| Honest nulls | Fields Hugging Face does not publish come back `null` or `""`. |

#### Email hygiene inside the Hugging Face Profile Email Scraper

The same hygiene applies to harvested and bio addresses alike. Obfuscation is undone before matching, so `[at]`, `(dot)`, spaced `a @ b`, zero-width characters and full-width `＠` are all handled, and domain matching is boundary-correct so `@gmail.com` does not match inside `@gmail.company`.

The Hugging Face Profile Email Scraper drops placeholder locals such as `email@`, `yourname@`, `example@` and `noreply@`, along with prose words used as locals. Real role addresses like `hi@` and `hello@` are kept, because researchers and labs use them.

### Input schema

The Hugging Face Profile Email Scraper ships exactly these inputs, with no hidden switches.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array | prefilled with example terms | Search terms. The Actor harvests Hub accounts publishing an address alongside each term, then enriches every one. |
| `location` | string | `""` | Added to every keyword search, e.g. `New York`. Keyword search only. |
| `maxPagesPerKeyword` | integer 1-30 | `5` | Google results pages read per query. Raise to find more accounts. Keyword search only. |
| `expandQueries` | boolean | `true` | Search each keyword in several phrasings (keyword + `email`, + `contact`, ...) to reach accounts a single query misses. Keyword search only. |
| `queryModifiers` | array | `email`, `contact`, `maintainer`, `author`, `support` | Extra words combined with each keyword when expansion is on. |
| `profileUrls` | array | `[]` | Full profile URLs. Bare usernames also accepted. |
| `usernames` | array | `[]` | Handles without the URL. Combined with the list above. |
| `customDomains` | array | `[]` | Domains the keyword search asks Google for, and a filter on the addresses kept. Empty searches the common free-mail providers and keeps every address found. |
| `onlyWithEmail` | boolean | `false` | Skip accounts for which no public address was found. |
| `maxProfiles` | integer 1-100000 | `100` | Stop after this many profiles are saved. |
| `maxConcurrency` | integer 1-30 | `10` | How many profiles are fetched, and Google searches run, in parallel. Higher is faster; lower it if rows come back blocked. |
| `proxyGroup` | select | `RESIDENTIAL` | `RESIDENTIAL`, `BUYPROXIES94952` or `UNBLOCKER`. |
| `countryCode` | string | `""` | Two-letter proxy country (US, GB, DE...). Empty for any. |

#### Input example

Both ways in, in one run. Drop `keywords` to enrich a list you have, or drop the URL lists to let the Hugging Face Profile Email Scraper find the accounts for you.

```json
{
  "keywords": [
    "speech recognition",
    "dataset maintainer"
  ],
  "location": "",
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "author"
  ],
  "profileUrls": [
    "https://huggingface.co/username",
    "third-user"
  ],
  "usernames": ["fourth_user"],
  "customDomains": [],
  "onlyWithEmail": true,
  "maxProfiles": 100,
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "countryCode": ""
}
```

### Output schema

Every dataset row from the Hugging Face Profile Email Scraper has the fields below, whether or not the platform published a value for each one.

| Field | Meaning |
|---|---|
| `success` | True when the profile was fetched and parsed, **or** an address was found for the account. A blocked profile fetch still yields a usable row when the harvest supplied an address. |
| `network` | Platform name |
| `dataSource` | Which path produced the profile data: always `page` here |
| `keyword` | The keyword that found this account, or `null` for a supplied URL |
| `query` | The exact Google query that found it, or `null` |
| `description` | The result snippet Google showed, cleaned of labels and counters |
| `profileUrl` | The canonical profile URL that was requested |
| `url` | The URL actually returned, after redirects |
| `username` | Handle |
| `fullName` | Display/real name as published |
| `displayName` | Handle or title the platform shows |
| `email` | First public email found, or `null` |
| `emails` | Every public email found, deduplicated |
| `emailSource` | Where the addresses came from: `search` (the Google harvest, the common value on a keyword run), `bio` (the profile page), `bio+search`, or `null` |
| `bio` | Public bio / description text |
| `avatarUrl` | Profile picture URL |
| `error` | Why a row failed, or `null` |
| `scrapedAt` | ISO 8601 UTC timestamp |

#### Output example

A single row exactly as the Hugging Face Profile Email Scraper writes it. The `null` counts are the honest shape of a Hugging Face row, not a failure.

```json
{
  "success": true,
  "network": "Hugging Face",
  "dataSource": "page",
  "keyword": "speech recognition",
  "query": "site:huggingface.co speech recognition contact \"@gmail.com\"",
  "description": "Jordan Ellis - ML engineer working on small language models and evaluation. Collabs: jordan.ellis at example.com",
  "profileUrl": "https://huggingface.co/username",
  "url": "https://huggingface.co/username",
  "username": "username",
  "fullName": "Jordan Ellis",
  "displayName": "username",
  "email": "jordan.ellis@example.com",
  "emails": ["jordan.ellis@example.com"],
  "emailSource": "bio+search",
  "bio": "ML engineer, small language models and evaluation. Collabs: jordan.ellis@example.com",
  "avatarUrl": "https://huggingface.co/avatars/example.png",
  "error": null,
  "scrapedAt": "2026-08-29T10:15:42.117Z"
}
```

### How to use the Hugging Face Profile Email Scraper step by step

1. Start from a keyword if you have no list yet. Put terms such as `speech recognition` into `keywords` and the Hugging Face Profile Email Scraper harvests Hub accounts publishing an address alongside that term.
2. Optionally set `location` to bias that search, and raise `maxPagesPerKeyword` from `5` to reach further down the results.
3. Leave `expandQueries` on so each keyword is also searched with `queryModifiers`; edit that list to steer the harvest towards your niche.
4. Or build the target list yourself: browse the Hub by library, task or organisation and collect the handles you want to reach.
5. Paste those URLs into `profileUrls`, or bare handles into `usernames`. Mixing keywords, URLs and handles is fine; duplicates are removed automatically.
6. Set `onlyWithEmail` to `true` if you only want rows that already carry an address. Leave it `false` to keep the full public dataset.
7. Add domains to `customDomains` if you only want, say, university or company addresses — they set what the harvest asks Google for and filter what is kept.
8. Set `maxProfiles` to your batch size and leave `maxConcurrency` at `10`. Lower it if you start seeing blocked rows.
9. Keep `proxyGroup` on `RESIDENTIAL`. Set `countryCode` only if you have a reason to pin the exit country.
10. Run it, then export the dataset as CSV, JSON or Excel, or pull it into your CRM through the Apify API or an integration.

A good habit: run 10 profiles first, check the rows, then scale. The Hugging Face Profile Email Scraper is resumable, so a restarted run continues instead of refetching.

### Use cases

A keyword run returns model authors who published a way to reach them, not every account that happens to contain the word.

**AI/ML talent sourcing.** Turn a shortlist of model authors into a contact list for recruiting outreach, with the public bio attached as context for a personalised first message.

**Developer relations.** Reach maintainers whose models or datasets build on your library, using this Hugging Face contact discovery step as the enrichment stage of your pipeline.

**Research collaboration.** Collect public contact points for authors working on the same task or benchmark, without hunting each profile by hand.

**Lead enrichment.** You already have handles in a spreadsheet or CRM. The Hugging Face Profile Email Scraper fills in name, public bio, avatar, external link and email against each one.

**Community management.** Keep a roster of open source contributors current, with `scrapedAt` on every row.

### Limitations

The real boundaries of the Hugging Face Profile Email Scraper, worth reading before a large batch.

**Statistics are usually absent.** `followersCount`, `followingCount`, `postsCount`, `likesCount` and the account flags typically come back `null`.

**Public profile pages and public search results only.** No model cards, dataset cards, Spaces, repository files, commit metadata or discussion threads. The harvest reads Google results for pages the Hub published.

**Yield varies.** The harvest asks for pages that publish an address, so most keyword rows carry one — but how many depends on the niche, and there is no rate to promise.

**Keyword search needs the GOOGLE\_SERP proxy.** It is the only route to Google, so a keywords-only run fails with a clear message without it. A run that also supplies profile URLs warns and continues.

**No email is invented.** If nothing was published on an indexed page or in the bio, `email` and `emailSource` are both `null`. The Hugging Face Profile Email Scraper finds published addresses; it never pattern-builds them.

**Public data only.** No login, no cookies, no private or official API, no browser and no JavaScript rendering. Anything a signed-out visitor cannot see is not collected.

**Blocking happens.** Pages can rate-limit or redirect to a login screen. The Hugging Face Profile Email Scraper retries up to 4 times with a fresh exit IP; a blocked fetch with no harvested address returns `success: false` and a reason in `error`.

**Plan cap and compliance.** The free Apify plan caps a run at 100 profiles; paid plans are uncapped and `maxProfiles` accepts up to 100000. Verify your own legal basis under GDPR, CAN-SPAM and local rules before contacting anyone.

### Pricing and run behaviour

The Hugging Face Profile Email Scraper is pay-per-event. It charges `actor-start` once per run and `profile-scraped` for each row saved to the dataset.

Rows stream as they are found: enrichment starts the moment the harvest finds an account, so the first rows save seconds into a run and keep arriving while the search continues. Each row is logged as written, naming the handle, the address and the counts found.

At the end the run reports counts of ok, blocked, not found and errors.

Progress is keyed to a hash of the input. A migrated or restarted run continues where it left off; changing the input starts a clean run.

### FAQ about the Hugging Face Profile Email Scraper

**How does keyword search work?**
In two phases. First a Google harvest on the GOOGLE\_SERP proxy, using an email dork — `site:huggingface.co <keyword> "@gmail.com"` — expanded across keywords, query modifiers and address domains and paged up to `maxPagesPerKeyword`, so each result yields a handle and a published address together. Then profile enrichment on the RESIDENTIAL proxy, merging both into one row.

**Why harvest first instead of just fetching profiles?**
Because pages that already carry an address return handles and emails in the same request, while fetching every profile and hoping for a bio address is one request each, and most bios have none.

**Do profile URLs and usernames still work?**
Yes, unchanged. Supply `profileUrls`, `usernames`, `keywords` or any combination; accounts you list directly skip the harvest and are enriched first, then whatever the harvest discovers.

**What are `keyword`, `query` and `description` for?**
The term that found the account, the exact Google query that found it, and the result snippet Google showed, cleaned of labels and counters. All three are empty for an account you supplied directly.

**Why is `success` true on a row with no profile data?**
Because `success` is true when the profile was fetched **or** an address was found. A blocked fetch on an account the harvest already had an address for still gives you a usable contact row.

**Does the Hugging Face Profile Email Scraper return follower counts?**
Usually not. Hugging Face profiles expose a name, bio and avatar rather than follower statistics, so those fields are normally `null`. The Instagram, TikTok, YouTube, Twitch, Pinterest, Threads, SoundCloud and Mastodon siblings are the ones that return full statistics.

**Does the Hugging Face Profile Email Scraper read model cards or repository files?**
No. It reads the public profile page and public search results for pages the Hub published. Model cards, dataset cards, Spaces, commit metadata and discussions are never opened, so an address buried in a README will not appear.

**Can the Hugging Face Profile Email Scraper find private or hidden email addresses?**
No. It only surfaces addresses a person published on an already-indexed public page or in their own bio, display name or external link. There is nothing hidden or private in the output.

**Do I need a Hugging Face account or API key?**
No. There is no login, no cookies, no private or official API and no browser rendering. The Hugging Face Profile Email Scraper fetches the same page an anonymous visitor gets.

**What if a profile has no email?**
The Hugging Face Profile Email Scraper still saves the row with `email` and `emailSource` set to `null`, unless `onlyWithEmail` is `true`, in which case it is skipped.

**Why is `dataSource` always `page`?**
Because the profile data has one route here: fetch and parse the public page. The `api` and `api+page` values exist in the shared schema for the TikTok sibling only.

**Can I filter to company or university domains?**
Yes. `customDomains` does two jobs: it sets the address domains the harvest asks Google for, and it filters what is kept. Leave it empty to search the common free-mail providers and keep everything found.

**Some rows came back with `success: false`. What now?**
The page was blocked or unreachable after 4 attempts and no address was harvested either. Lower `maxConcurrency`, keep `proxyGroup` on `RESIDENTIAL`, and rerun the failed handles.

**Can I use the output for cold email campaigns?**
That is your decision and your legal responsibility. The Hugging Face Profile Email Scraper gives you published contact points; consent, opt-out handling and local law are on you.

### Related Actors

The Hugging Face Profile Email Scraper is one of 30 profile Actors sharing the same engine, input schema and output schema.

| Actor | What it collects |
|---|---|
| [Hugging Face Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/hugging-face-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Hugging Face |
| [Hugging Face Profile Phone Number Scraper](https://apify.com/neuro-scraper/hugging-face-profile-phone-number-scraper) | Phone numbers plus bio and follower counts from Hugging Face profiles |
| [Behance Profile Email Scraper](https://apify.com/leads-scraper/behance-profile-email-scraper) | Emails plus bio and follower counts from Behance profiles |
| [Bluesky Profile Email Scraper](https://apify.com/leads-scraper/bluesky-profile-email-scraper) | Emails plus bio and follower counts from Bluesky profiles |
| [Buy Me a Coffee Profile Email Scraper](https://apify.com/neuro-scraper/buy-me-a-coffee-profile-email-scraper) | Emails plus bio and follower counts from Buy Me a Coffee profiles |
| [DEV Community Profile Email Scraper](https://apify.com/neuro-scraper/dev-to-profile-email-scraper) | Emails plus bio and follower counts from DEV Community profiles |
| [DeviantArt Profile Email Scraper](https://apify.com/leads-scraper/deviantart-profile-email-scraper) | Emails plus bio and follower counts from DeviantArt profiles |
| [Dribbble Profile Email Scraper](https://apify.com/leads-scraper/dribbble-profile-email-scraper) | Emails plus bio and follower counts from Dribbble profiles |
| [Facebook Profile Email Scraper](https://apify.com/leads-scraper/facebook-profile-email-scraper) | Emails plus bio and follower counts from Facebook profiles |
| [Flipboard Profile Email Scraper](https://apify.com/neuro-scraper/flipboard-profile-email-scraper) | Emails plus bio and follower counts from Flipboard profiles |
| [GitHub Profile Email Scraper](https://apify.com/leads-scraper/github-profile-email-scraper) | Emails plus bio and follower counts from GitHub profiles |
| [GitLab Profile Email Scraper](https://apify.com/neuro-scraper/gitlab-profile-email-scraper) | Emails plus bio and follower counts from GitLab profiles |
| [Gumroad Profile Email Scraper](https://apify.com/leads-scraper/gumroad-profile-email-scraper) | Emails plus bio and follower counts from Gumroad profiles |
| [Hashnode Profile Email Scraper](https://apify.com/neuro-scraper/hashnode-profile-email-scraper) | Emails plus bio and follower counts from Hashnode profiles |
| [Instagram Profile Email Scraper](https://apify.com/leads-scraper/instagram-profile-email-scraper) | Emails plus bio and follower counts from Instagram profiles |
| [Kick Profile Email Scraper](https://apify.com/leads-scraper/kick-profile-email-scraper) | Emails plus bio and follower counts from Kick profiles |
| [Linktree Profile Email Scraper](https://apify.com/leads-scraper/linktree-profile-email-scraper) | Emails plus bio and follower counts from Linktree profiles |
| [Mastodon Profile Email Scraper](https://apify.com/leads-scraper/mastodon-profile-email-scraper) | Emails plus bio and follower counts from Mastodon profiles |
| [Mixcloud Profile Email Scraper](https://apify.com/leads-scraper/mixcloud-profile-email-scraper) | Emails plus bio and follower counts from Mixcloud profiles |
| [Patreon Profile Email Scraper](https://apify.com/leads-scraper/patreon-profile-email-scraper) | Emails plus bio and follower counts from Patreon profiles |
| [Pinterest Profile Email Scraper](https://apify.com/leads-scraper/pinterest-profile-email-scraper) | Emails plus bio and follower counts from Pinterest profiles |
| [Snapchat Profile Email Scraper](https://apify.com/leads-scraper/snapchat-profile-email-scraper) | Emails plus bio and follower counts from Snapchat profiles |
| [SoundCloud Profile Email Scraper](https://apify.com/leads-scraper/soundcloud-profile-email-scraper) | Emails plus bio and follower counts from SoundCloud profiles |
| [Substack Profile Email Scraper](https://apify.com/leads-scraper/substack-profile-email-scraper) | Emails plus bio and follower counts from Substack profiles |
| [Telegram Profile Email Scraper](https://apify.com/leads-scraper/telegram-profile-email-scraper) | Emails plus bio and follower counts from Telegram profiles |
| [Threads Profile Email Scraper](https://apify.com/leads-scraper/threads-profile-email-scraper) | Emails plus bio and follower counts from Threads profiles |
| [TikTok Profile Email Scraper](https://apify.com/leads-scraper/tiktok-profile-email-scraper) | Emails plus bio and follower counts from TikTok profiles |
| [Tumblr Profile Email Scraper](https://apify.com/leads-scraper/tumblr-profile-email-scraper) | Emails plus bio and follower counts from Tumblr profiles |
| [Twitch Profile Email Scraper](https://apify.com/leads-scraper/twitch-profile-email-scraper) | Emails plus bio and follower counts from Twitch profiles |
| [X Profile Email Scraper](https://apify.com/leads-scraper/x-profile-email-scraper) | Emails plus bio and follower counts from X profiles |
| [YouTube Profile Email Scraper](https://apify.com/leads-scraper/youtube-profile-email-scraper) | Emails plus bio and follower counts from YouTube profiles |
| [Behance Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/behance-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Behance |
| [Bluesky Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/bluesky-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Bluesky |
| [Buy Me a Coffee Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/buy-me-a-coffee-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Buy Me a Coffee |
| [DEV Community Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/dev-to-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from DEV Community |
| [DeviantArt Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/deviantart-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from DeviantArt |
| [Dribbble Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/dribbble-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Dribbble |
| [Facebook Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/facebook-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Facebook |
| [Flipboard Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/flipboard-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Flipboard |
| [GitHub Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/github-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from GitHub |
| [GitLab Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from GitLab |
| [Gumroad Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/gumroad-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Gumroad |

### Support

Questions about the Hugging Face Profile Email Scraper, bug reports, or a custom build for your workflow: email <neurodata.apify@gmail.com>.

Please include the run ID and a couple of the profile URLs involved — that makes an issue much faster to reproduce and fix.

# Actor input Schema

## `keywords` (type: `array`):

Search terms - a niche, job title or industry. The Actor finds Hugging Face accounts matching each term, then scrapes every account it finds. Use this when you do not already have a list of accounts. You can combine keywords with the profile URLs below.

## `location` (type: `string`):

Added to every keyword search, e.g. `New York`. Leave empty to search everywhere. Only applies to keyword search.

## `profileUrls` (type: `array`):

Full Hugging Face profile URLs, e.g. `https://huggingface.co/username`. Bare usernames also work. Use this when you already know which accounts you want.

## `usernames` (type: `array`):

Hugging Face handles without the URL. Combined with the list above.

## `customDomains` (type: `array`):

Domains the keyword search asks Google for, e.g. `@gmail.com`. Also filters results to these domains. Leave EMPTY (recommended) to search the 12 biggest free-mail providers - Gmail, Yahoo, Outlook, Hotmail, iCloud, AOL, Proton, Live, GMX, Mail.com, Yandex and Zoho - and keep every address found, including company domains. Listing domains here narrows the search to only those.

## `onlyWithEmail` (type: `boolean`):

Skip profiles whose public bio contains no contact address.

## `maxProfiles` (type: `integer`):

Stop after this many profiles have been saved.

## `maxPagesPerKeyword` (type: `integer`):

How many Google results pages to read per search query. Raise it to find more accounts. Keyword search only.

## `expandQueries` (type: `boolean`):

Search each keyword in several phrasings (keyword + "email", + "contact", ...) to reach accounts a single query misses. Keyword search only.

## `queryModifiers` (type: `array`):

Extra words combined with each keyword when query expansion is on. Leave empty to use the defaults for this platform.

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

How many profiles are fetched in parallel, and how many Google searches run at once. Raise it for speed, lower it if you see blocked rows.

## `proxyGroup` (type: `string`):

RESIDENTIAL is recommended. Profile pages block datacenter IPs.

## `countryCode` (type: `string`):

Two-letter country code for the proxy (e.g. US, GB, DE). Empty for any.

## Actor input object example

```json
{
  "keywords": [
    "machine learning",
    "model author"
  ],
  "location": "",
  "profileUrls": [],
  "usernames": [],
  "customDomains": [],
  "onlyWithEmail": false,
  "maxProfiles": 100,
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "maintainer",
    "author",
    "support"
  ],
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "countryCode": ""
}
```

# Actor output Schema

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

Records produced by Hugging Face Profile Email Scraper, stored in the run's 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 = {
    "keywords": [
        "machine learning",
        "model author"
    ],
    "location": "",
    "countryCode": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("neuro-scraper/hugging-face-profile-email-scraper").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 = {
    "keywords": [
        "machine learning",
        "model author",
    ],
    "location": "",
    "countryCode": "",
}

# Run the Actor and wait for it to finish
run = client.actor("neuro-scraper/hugging-face-profile-email-scraper").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 '{
  "keywords": [
    "machine learning",
    "model author"
  ],
  "location": "",
  "countryCode": ""
}' |
apify call neuro-scraper/hugging-face-profile-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neuro-scraper/hugging-face-profile-email-scraper"
        }
    }
}

```

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/2kqEDn7bCJf69nuAw/builds/Clluu7UphCAJcaQy1/openapi.json