# GitHub Developer Lead Finder & Email Enricher (`fayoussef/github-developer-leads`) Actor

Find developers on GitHub and enrich each one with verified email, company, location, skills, and social links for recruiting and B2B outreach.

- **URL**: https://apify.com/fayoussef/github-developer-leads.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 results

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?

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

## GitHub Developer Lead Finder & Email Enricher 🧑‍💻📧

**Find developers on GitHub and turn them into outreach-ready leads — complete with verified emails, company, location, skills, and social links.** Perfect for technical recruiters, DevRel teams, dev-tool founders, and B2B sales targeting developers.

Unlike profile-only GitHub scrapers, this Actor **mines public commit history to surface real, contactable emails** (the ones hidden from the profile page) and **infers each developer's tech stack** so you can segment by skill.

***

### 💡 What it does

Give it a search, and it returns a clean dataset of developer leads. Five ways to find people:

| Search type | What you get |
|---|---|
| **User search** | Anyone matching a GitHub query — e.g. `language:Rust location:Berlin followers:>100` |
| **Repository search** | Contributors of repos matching a query — e.g. `langchain stars:>500` |
| **Stargazers** | Everyone who starred a repo (your competitor's repo = your warm leads) |
| **Contributors** | Everyone who committed to specific repos |
| **Organization members** | Public members of any GitHub org |

Each lead is enriched with:

- ✅ **Email** — from the profile *and* mined from public commits (the high-value part)
- 🏢 **Company**, 📍 **location**, 📝 **bio**, and the **"available for hire"** flag
- 🧠 **Top programming languages** and **total stars earned** (skill & influence signal)
- 🔗 **Twitter / X**, **personal website / blog**, **LinkedIn** (when discoverable)
- 📊 Followers, following, public repos, account age

***

### 🚀 Quick start

1. Pick a **Search type**.
2. Fill the matching field:
   - *User / Repository search* → **Search query**
   - *Stargazers / Contributors* → **Repositories** (e.g. `facebook/react`)
   - *Organization members* → **Organizations** (e.g. `vercel`)
3. (Recommended) Paste a **GitHub token** to unlock 5,000 requests/hour.
4. Click **Start**.

#### Example: find hireable React-ecosystem developers in Europe

```json
{
  "searchType": "users",
  "searchQuery": "language:JavaScript location:Germany followers:>200",
  "onlyHireable": true,
  "extractEmails": true,
  "maxItems": 300,
  "githubToken": "ghp_xxx"
}
```

#### Example: leads from a competitor's stargazers

```json
{
  "searchType": "stargazers",
  "repositories": ["supabase/supabase"],
  "onlyWithEmail": true,
  "maxItems": 1000
}
```

***

### 📤 Output sample

```json
{
  "username": "octodev",
  "name": "Octo Developer",
  "email": "octo@example.com",
  "emails": ["octo@example.com", "octo@work.io"],
  "company": "Acme Inc",
  "location": "Berlin, Germany",
  "bio": "Backend engineer. Go, Rust, distributed systems.",
  "hireable": true,
  "website": "https://octo.dev/",
  "linkedin": null,
  "twitterUsername": "octodev",
  "followers": 842,
  "topLanguages": ["Go", "Rust", "TypeScript", "Python"],
  "totalStars": 5120,
  "publicRepos": 73,
  "githubUrl": "https://github.com/octodev",
  "scrapedAt": "2026-05-30T10:00:00.000Z"
}
```

Export to **JSON, CSV, Excel, or via API** — drop straight into your CRM, Clay table, or cold-email tool.

***

### 🔑 GitHub token (highly recommended)

Without a token GitHub allows only **60 requests/hour**. With a free Personal Access Token you get **5,000/hour**, so larger runs finish reliably.

1. Go to **https://github.com/settings/tokens**
2. Generate a token — **no scopes are required** for public data (classic or fine-grained both work).
3. Paste it into the **GitHub token** field. It's stored as a secret.

***

### 💰 Pricing (pay-per-event)

You only pay for results you receive:

| Event | What it covers |
|---|---|
| **Profile scraped** | Each enriched developer profile delivered to your dataset |
| **Email enriched** | Charged only when a contactable email is actually found |
| *Actor start* | Apify's standard low start fee (covers run startup) |

No subscription, no per-result charge when nothing is found.

***

### ⚙️ Options reference

| Option | Default | Description |
|---|---|---|
| `searchType` | `users` | How to find developers (see table above) |
| `searchQuery` | — | GitHub search syntax (user/repository search) |
| `repositories` | — | `owner/name` list (stargazers/contributors) |
| `organizations` | — | Org logins (organization members) |
| `maxItems` | `200` | Max leads to return |
| `extractEmails` | `true` | Mine emails from profile + commit history |
| `deepEmailSearch` | `false` | Also scan owned-repo commits when no email is found (slower) |
| `includeNoreplyEmails` | `false` | Include anonymized `@users.noreply.github.com` addresses |
| `enrichStats` | `true` | Add top languages + total stars |
| `onlyWithEmail` | `false` | Keep only leads with an email |
| `onlyHireable` | `false` | Keep only developers open to work |
| `minFollowers` | `0` | Skip developers below this follower count |
| `githubToken` | — | Personal Access Token for higher rate limits |

***

### 🧭 Use cases

- **Technical recruiting** — find hireable engineers by language, location, and influence.
- **Dev-tool sales & DevRel** — turn stargazers/contributors of relevant repos into a warm outreach list.
- **Open-source intelligence** — map who builds what across an ecosystem.
- **Community building** — identify active contributors to invite or sponsor.

***

### ❓ FAQ

**Where do the emails come from?**
Git commits store the author's email, and GitHub exposes recent public commits via its API. This Actor reads those public commit records (and the profile email) and filters out non-contactable `noreply` addresses. Everything used is publicly available through GitHub's official API.

**Why is `email` sometimes empty?**
Many developers commit using GitHub's privacy email or have no public activity. Enable `deepEmailSearch` for a more thorough scan, or set `onlyWithEmail` to keep only leads that have one.

**Is this reliable at scale?**
Yes — it uses GitHub's official REST API (no fragile HTML scraping, no proxies), with automatic rate-limit handling and retries.

***

### 📜 Responsible use

This Actor only accesses **public** data via GitHub's official API. Use the data in compliance with GitHub's Terms of Service and applicable privacy/marketing laws (e.g. GDPR/CAN-SPAM) when contacting people.

# Actor input Schema

## `searchType` (type: `string`):

How to find developers:

- **User search** – GitHub's user search (use the query field, e.g. `language:Go location:Berlin followers:>100`).
- **Repository search** – find repos by query, then collect their contributors.
- **Stargazers** – everyone who starred the given repositories.
- **Contributors** – everyone who committed to the given repositories.
- **Organization members** – public members of the given organizations.

## `searchQuery` (type: `string`):

GitHub search query. Used for the **User search** and **Repository search** types. Supports full GitHub search syntax. Examples: `language:Python location:"San Francisco" followers:>500`, `machine learning stars:>1000`.

## `repositories` (type: `array`):

List of repositories as `owner/name` (or full GitHub URLs). Used for the **Stargazers** and **Contributors** search types.

## `organizations` (type: `array`):

List of GitHub organization logins (or full URLs). Used for the **Organization members** search type. Note: only publicly visible members are returned.

## `maxItems` (type: `integer`):

Maximum number of developer profiles to return. Keep this sensible to control cost — GitHub search is capped at 1,000 results per query.

## `extractEmails` (type: `boolean`):

Try to find each developer's email. Uses the public profile email first, then mines recent public commit history (where most real emails actually live).

## `deepEmailSearch` (type: `boolean`):

If no email is found from public events, also scan commits inside the developer's own repositories. More thorough but uses extra API calls (slower).

## `includeNoreplyEmails` (type: `boolean`):

Include anonymized `@users.noreply.github.com` addresses. These are not contactable, so they are excluded by default.

## `enrichStats` (type: `boolean`):

Add inferred top programming languages, total stars earned, and pinned-repo signals by scanning the developer's repositories. Uses extra API calls.

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

Skip developers for whom no contactable email was found.

## `onlyHireable` (type: `boolean`):

Keep only developers who set the "available for hire" flag on their GitHub profile. Great for technical recruiting.

## `minFollowers` (type: `integer`):

Skip developers with fewer than this many followers.

## `githubToken` (type: `string`):

A GitHub Personal Access Token (classic or fine-grained, no scopes required for public data). **Without a token you are limited to GitHub's unauthenticated rate of 60 requests/hour, which caps a run at roughly 20 leads per hour.** Strongly recommended: a token raises your rate limit from 60 to 5,000 requests/hour, so larger runs finish reliably. Create one at https://github.com/settings/tokens

## Actor input object example

```json
{
  "searchType": "users",
  "searchQuery": "language:TypeScript location:London followers:>100",
  "repositories": [
    "facebook/react"
  ],
  "organizations": [
    "vercel"
  ],
  "maxItems": 200,
  "extractEmails": true,
  "deepEmailSearch": false,
  "includeNoreplyEmails": false,
  "enrichStats": true,
  "onlyWithEmail": false,
  "onlyHireable": false,
  "minFollowers": 0
}
```

# Actor output Schema

## `leads` (type: `string`):

All enriched developer profiles collected in this run. Open in the Console table view or fetch via the dataset API.

# 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 = {
    "searchQuery": "language:TypeScript location:London followers:>100",
    "repositories": [
        "facebook/react"
    ],
    "organizations": [
        "vercel"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/github-developer-leads").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 = {
    "searchQuery": "language:TypeScript location:London followers:>100",
    "repositories": ["facebook/react"],
    "organizations": ["vercel"],
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/github-developer-leads").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 '{
  "searchQuery": "language:TypeScript location:London followers:>100",
  "repositories": [
    "facebook/react"
  ],
  "organizations": [
    "vercel"
  ]
}' |
apify call fayoussef/github-developer-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fayoussef/github-developer-leads"
        }
    }
}

```

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/DQCQ3shQByF2ogMAI/builds/kKIPdT6OncyDcfMbi/openapi.json