GitHub Email Scraper

📧 GitHub Email Scraper – Developer Contact & Lead Data Extraction by Keyword

The GitHub Email Scraper finds publicly indexed email addresses associated with GitHub profiles and repositories, returning each one as a structured lead record containing the address, the keyword that surfaced it, the page title and description, and the source URL. It is built for technical recruiters, developer-relations teams, open-source maintainers running outreach, and B2B sales teams selling developer tooling.

The Actor works by issuing targeted search queries scoped to github.com, combining each of your keywords with each of your chosen email domains — a search-operator technique that surfaces addresses developers have chosen to publish on their profiles and project pages. You supply the keywords, optionally a location filter and a list of email domains, set a cap on how many addresses to collect, and the Actor works through every keyword-and-domain combination until it hits your limit.

Because collection is bounded by an explicit maxEmails cap and progress is persisted between pages, this GitHub email scraper is predictable to run and cheap to control — you decide exactly how much data a run should produce before it starts.

---

📊 What Data Can You Extract with This GitHub Email Scraper?

Each dataset item is one unique email address together with the context in which it was found:

Category	Fields	What you get
📧 Contact data	email	The extracted email address, deduplicated across the run
🔍 Search attribution	keyword	The specific keyword from your input list that produced this result
📄 Page context	title, description	The result title and the surrounding descriptive text from the source page
🔗 Provenance	url	The canonical URL of the page where the address was discovered
🌐 Source platform	network	The platform the record came from — Github.com for every item this Actor produces

The field doing the most useful work is keyword. Because each address carries the exact search term that surfaced it, you can measure which keywords actually produce contacts and which are wasted effort — turning your next run's keywords list into an informed decision rather than a guess.

---

🌟 Key Features of the GitHub Email Scraper

Feature	Description
🔍 Multi-keyword search	keywords accepts a list of queries — job titles, technologies, roles — and each is combined with every configured email domain
📮 Custom email domain targeting	customDomains lets you specify which mailbox providers or corporate domains to hunt for, defaulting to @gmail.com and @yahoo.com
📍 Optional location filtering	The location field adds a geographic term to each query, narrowing results to developers who list that location
🎯 Hard collection cap	maxEmails stops the run at your chosen number, anywhere from 1 to 10,000, giving you direct control over run cost and duration
🧹 Automatic deduplication	Addresses already seen during a run are tracked and never written twice, so the dataset contains unique contacts
💾 Resumable progress	The keyword and domain cursor is persisted to a key-value store, so a long extraction resumes from where it left off rather than restarting
🔁 Automatic proxy rotation	Proxy handling, session rotation and retry logic are managed internally — no proxy configuration is required from you
🖥️ Rotating browser fingerprints	Requests cycle through a pool of realistic mobile user-agent strings, reducing the chance of a run being interrupted
⚡ Browser-free architecture	Pages are fetched and parsed directly rather than rendered in headless Chrome, keeping runs fast and memory-light

---

🚀 Why Choose This GitHub Email Scraper?

Domain targeting makes the output segmented by design. customDomains controls exactly which mailbox providers appear in your results. Set it to consumer providers for individual developer outreach, or to specific corporate domains when you are targeting employees of a particular company. The filtering happens in the query itself, so you are not paying to collect addresses you intended to discard.

Every result is fully attributable. keyword, title, description and url travel with each address. A recruiter can see at a glance which search produced a contact and what the source page said about them, which is what makes a first outreach message specific rather than generic — and what makes the dataset defensible from a compliance standpoint.

Cost is bounded before the run starts. maxEmails is a hard stop, not a suggestion. Combined with persisted progress tracking, this means a run either delivers the number of contacts you asked for or exhausts the available results — there is no scenario where an unbounded crawl runs away with your budget.

Sensible defaults, minimal setup. Only keywords is required, and even that ships with a working prefill. Location is optional, domains have defaults, and the cap starts at a conservative 20. You can produce a useful first dataset in under a minute and refine from there.

---

📥 Input

The GitHub email scraper needs one required field, keywords. Everything else refines the search.

{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}

🔧 GitHub Email Scraper Input Fields

Field	Type	Required	Default	Description
keywords	array	✅ Yes	["manager", "founder"]	A list of keywords or queries to search for
location	string	No	"" (empty)	Location to filter search results
customDomains	array	No	["@gmail.com", "@yahoo.com"]	List of custom email domains
maxEmails	integer	No	20	Maximum number of emails to collect. The scraper stops once this limit is reached. Setting a higher limit allows for more potential results but does not guarantee reaching that number. Minimum 1, maximum 10,000

💡 Input Examples

Targeting backend engineers in Berlin:

{
  "keywords": ["backend engineer", "golang developer"],
  "location": "Berlin",
  "customDomains": ["@gmail.com"],
  "maxEmails": 100
}

Broad technical recruiting sweep:

{
  "keywords": ["machine learning", "data engineer", "devops", "site reliability"],
  "customDomains": ["@gmail.com", "@outlook.com", "@protonmail.com"],
  "maxEmails": 500
}

Quick validation run:

{
  "keywords": ["rust developer"],
  "maxEmails": 20
}

---

📤 Output

Each unique email address becomes one dataset item. A representative record:

{
  "network": "Github.com",
  "keyword": "backend engineer",
  "title": "alexdev (Alex Moreau) · GitHub",
  "description": "Backend engineer working on distributed systems in Go and Rust. Berlin. Reach me at alex.moreau.dev@gmail.com for collaboration.",
  "url": "https://github.com/alexdev",
  "email": "alex.moreau.dev@gmail.com"
}

🧾 GitHub Email Scraper Output Fields

Field	Type	Description
network	string | null	Network of the item
keyword	string | null	Keyword that produced this item
title	string | null	Title of the item
description	string | null	Long-form description text
url	string | null	Canonical URL of the scraped item
email	string | null	Email address found for the item

The network field is constant at Github.com for this Actor, which is useful when you merge its output with datasets from other platform scrapers — it keeps the combined table unambiguous about where each contact originated. All fields are nullable.

---

💻 How to Use the GitHub Email Scraper (Step by Step)

Step 1: Open the GitHub Email Scraper on Apify

Sign in to Apify and open the Actor page, then press Start to bring up the input form. A free account is enough to get going, and it provides a console where every run's log, configuration and dataset is preserved. That history is worth having for lead generation work — being able to point at the exact run that produced a contact is part of keeping the process auditable.

Step 2: Choose your keywords carefully

keywords is the single most influential input. Job titles work well (backend engineer, data scientist), as do technology names (kubernetes, pytorch) and role descriptors (founder, maintainer). Supply several related terms rather than one broad one — the Actor runs every keyword against every domain, so a list of four keywords and three domains produces twelve distinct search combinations, each contributing to your total. Overly generic single words return diffuse results; specific technical terms return fewer but far better matches.

Step 3: Decide whether to apply a location filter

location is optional and defaults to empty. Leaving it blank gives the broadest reach. Adding a value narrows every query to results that also mention that location, which is exactly what you want for regional hiring but will substantially reduce your yield. If a run with a location filter returns very little, try removing it or using a broader region — a country name rather than a city, for instance — before concluding the keywords are at fault.

Step 4: Configure your target email domains

customDomains defaults to @gmail.com and @yahoo.com. Adjust it to match who you are trying to reach. Consumer providers surface individual developers using personal addresses on their profiles. Adding corporate domains lets you target employees of specific organisations. Each domain multiplies the number of query combinations, so adding domains increases both reach and run duration.

Step 5: Set your collection cap

maxEmails defaults to 20, which is a sensible size for a first run. Keep it low while you evaluate whether your keyword and domain combination is producing relevant contacts. Once you are satisfied with the quality, raise it — up to 10,000 — and extend the run timeout in Run Options accordingly, since larger caps mean many more search pages to work through.

Step 6: Start the run and watch the log

Press Start. The log reports each keyword-and-domain pair as it is processed and prints every email as it is found and pushed to the dataset. This live visibility is genuinely useful: if the addresses appearing are not the kind you wanted, you can stop the run early, adjust the input, and restart rather than paying for a full run of unusable data. The log also surfaces suggestions when results are thin, such as removing a restrictive location filter.

Step 7: Review, verify and export

Open the Output tab and inspect the dataset before doing anything with it. Read a handful of description and title values to confirm the contacts genuinely match your target profile, and spot-check a few url values against the live pages. Export to CSV or JSON, then run every address through an email verification service before any outreach — extracted addresses are only as current as the page that published them.

---

🔌 API Access & Integrations

Run the GitHub email scraper through the Apify API and get the dataset back in a single call:

curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~github-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["manager", "founder"],
    "location": "",
    "customDomains": ["@gmail.com", "@yahoo.com"],
    "maxEmails": 20
  }'

The same with the official Python client:

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "keywords": ["backend engineer", "golang developer"],
    "location": "Berlin",
    "customDomains": ["@gmail.com"],
    "maxEmails": 100,
}

run = client.actor("scrapers-hub/github-email-scraper-fast-advanced-and-cheapest").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["email"], "|", item["keyword"], "|", item["url"])

The Actor also connects to Zapier, Make, Google Sheets, Slack, Airtable and any custom endpoint through Apify webhooks, so newly discovered developer contacts can flow directly into your CRM or ATS as each run finishes.

---

💡 Best Use Cases for GitHub Contact Data

🧑‍💻 Technical Recruiting and Talent Sourcing

Recruiters can set keywords to the stack they are hiring for — rust developer, kubernetes, react native — and optionally add a location to focus on a hiring region. The description field usually carries the developer's own profile bio, which gives a sourcer real context for a first message rather than a template. The url links straight back to the profile for verification.

🛠️ Developer Relations and Community Outreach

DevRel teams building relationships around a technology can search for keywords matching their ecosystem and reach maintainers who have published contact details. Grouping results by keyword shows which parts of the ecosystem have the densest active community, which is a useful input for deciding where to invest advocacy effort.

💼 B2B Sales for Developer Tooling

Companies selling CI/CD platforms, observability tools or developer infrastructure need to reach practitioners, not procurement. Keywords describing the relevant technical role, combined with corporate values in customDomains, produce a prospect list of people who actually use the category of product being sold.

🌍 Open-Source Contributor Discovery

Maintainers looking to grow a project can search keywords matching adjacent technologies to find developers already working in the same space. The title and description fields give enough signal to judge whether someone is a plausible contributor before any approach is made.

📊 Developer Ecosystem Research

Analysts studying technology adoption can run broad keyword sets and examine the distribution of results across terms. Because keyword is recorded per row, the relative volume of contacts surfaced by pytorch versus tensorflow, or golang versus rust, is a rough but genuine indicator of published activity in each area.

📣 Targeted Regional Campaigns

Setting location to a specific city or country and running a focused keyword set produces a geographically scoped contact list. Marketing teams use this for regional event promotion, local meetup recruitment, or campaigns where time zone and language matter to the message.

🔗 Partner and Freelancer Sourcing

Agencies needing specialist contractors can search for niche technical keywords that full-time job boards rarely cover well. The combination of description and url lets you assess actual published work before making contact, which is a stronger signal than a self-reported CV.

---

⚙️ Tips for Better GitHub Email Scraping Results

• Use specific technical keywords rather than generic ones. distributed systems engineer returns far more relevant contacts than engineer, and the per-row keyword field will show you which terms earned their place.
• Start without a location filter. location narrows every query and can cut yield sharply. Establish that your keywords work first, then add geography.
• Expand customDomains to widen reach. More domains means more query combinations and more potential results, at the cost of a longer run. Add corporate domains when targeting a specific employer.
• Keep maxEmails low for the first run. Twenty results is enough to judge relevance. Scale up only once you are confident the input is producing the right kind of contact.
• Extend the run timeout for large caps. A maxEmails value in the hundreds or thousands means many search pages. Increase the timeout in Run Options — the default is 3600 seconds — so a productive run is not cut short.
• Verify addresses before any outreach. Published addresses go stale. A verification pass protects your domain's sending reputation and keeps bounce rates manageable.

---

🛠️ Troubleshooting

The run returned fewer emails than maxEmails. Why? maxEmails is a ceiling, not a target. If your keyword, domain and location combination does not surface that many publicly indexed addresses, the run ends when results are exhausted. Broaden your keywords, add more entries to customDomains, or remove a restrictive location filter.

I set a location and got almost nothing back. Location filtering adds a literal term to every query, which is a significant constraint. Try a broader region — a country instead of a city — or remove the filter entirely and filter geographically afterwards using the description field.

Why are some title or description values empty? All output fields are nullable. Not every search result exposes a usable title or descriptive snippet, and the Actor records null rather than inventing a value.

Can I configure my own proxy? No proxy setting is exposed in the input. Proxy rotation, session handling and retry logic are managed internally by the Actor.

The run is taking a long time. What should I do? Long runs are usually a large maxEmails combined with many keyword-and-domain combinations. Reduce the cap, trim the keyword list, or extend the run timeout in Run Options. Progress is persisted, so the cursor position is not lost between pages.

---

❓ Frequently Asked Questions About GitHub Email Scraping

What does the GitHub Email Scraper actually do? It runs targeted searches scoped to github.com, combining each of your keywords with each of your chosen email domains, extracts the email addresses found in those results, and outputs each as a record with the keyword, page title, description and source URL.

What is the only required input? keywords. The location filter, custom domains and maximum email count all have defaults and are optional.

How does the domain filtering work? Each domain in customDomains is included in the search query itself, so results are constrained to pages publishing addresses on those domains. Defaults are @gmail.com and @yahoo.com.

Can I target corporate email domains instead of consumer ones? Yes. Replace the defaults in customDomains with the domains you want, for example @acme.com. This is the standard approach for reaching employees of a specific organisation.

How many emails can a single run collect? maxEmails accepts values from 1 to 10,000. Larger values require a correspondingly longer run timeout.

Do I need a GitHub account or personal access token? No. The Actor requires only your Apify token when run through the API, and nothing beyond a signed-in console session otherwise.

Are duplicate email addresses removed? Yes. Addresses seen earlier in a run are tracked and are not written to the dataset again.

What does the network field contain? The constant value Github.com, identifying the source platform. It is useful when merging this dataset with output from scrapers covering other platforms.

Are the extracted addresses verified as deliverable? No. The Actor extracts addresses exactly as published on the source pages. Run them through a dedicated verification service before any campaign.

Can I search multiple keywords in one run? Yes. keywords is an array, and every keyword is combined with every configured domain. Each output row records the specific keyword that produced it.

Does the GitHub email scraper use a headless browser? No. It fetches and parses pages directly, which keeps runs faster and lighter than browser-based approaches.

Can I resume a run that was interrupted? The Actor persists its keyword and domain cursor to a key-value store as it progresses, so a restarted run picks up from its recorded position rather than beginning again from scratch.

What export formats are supported? JSON, CSV, Excel, XML, HTML table and RSS, from the Apify dataset view or through the API.

Can I schedule the GitHub email scraper to run automatically? Yes. Use the Schedules feature in the Apify console to rerun the same configuration periodically and build a growing contact database.

Is scraping email addresses from GitHub legal? The Actor collects only publicly indexed information that developers have chosen to publish. However, email addresses relating to identifiable individuals are personal data under GDPR, CCPA and similar regimes. You need a lawful basis for processing, must honour opt-out requests, and must comply with anti-spam legislation such as GDPR, CAN-SPAM and PECR before sending any outreach.

---

🆘 Support & Feedback

If a run fails, results look wrong, or a field behaves differently from what is documented here, please open a report in the Issues tab on the Actor page so it can be tracked and resolved.

Need a custom build — additional fields, different source platforms, a tailored output shape, or a bespoke contact extraction workflow — email scraperhubapi@gmail.com with your requirements.

If the GitHub Email Scraper is useful to your work, a review on the Apify Store helps other users find it and directly shapes what gets improved next.

---

⚖️ Disclaimer

The GitHub Email Scraper collects only publicly available, publicly indexed information — email addresses that individuals have chosen to publish on profiles and project pages. It does not access private repositories, authenticated areas, or any data behind access controls.

Email addresses are personal data. If you use this GitHub email scraper to collect addresses relating to identifiable individuals, you become a data controller under GDPR, the UK GDPR, CCPA and comparable frameworks. That carries real obligations: you need a documented lawful basis for processing — legitimate interest is the usual route for B2B and recruitment outreach, and the balancing test must actually be performed; you must inform data subjects of your processing; you must honour access, rectification and erasure requests; and you must retain data only as long as it is genuinely needed.

Outreach using extracted addresses is separately regulated. GDPR, CAN-SPAM, CASL, PECR and equivalent anti-spam laws impose requirements around consent, accurate sender identification, truthful subject lines and working opt-out mechanisms. These apply regardless of how an address was obtained, and breaching them carries genuine penalties.

You are also responsible for complying with the terms of service of GitHub and of any search platform whose results the extraction touches, and for keeping request volumes at a level that does not burden those services.

This Actor is not affiliated with, endorsed by, or sponsored by GitHub, Inc. or Microsoft Corporation. If you believe data collected by this Actor relates to you and you would like it removed, contact scraperhubapi@gmail.com and the request will be handled promptly.