GitHub Followers Scraper — Developer Leads

GitHub Followers Scraper — Export Developer Leads (Name · Company · Location · Email · X)

Turn any GitHub account's followers into an enriched developer lead list. This GitHub followers scraper takes any GitHub user or organization and exports everyone who follows them — each row enriched with name, bio, company, location, website, public email and X/Twitter handle. It is the fastest way to scrape GitHub followers and build a targeted list of real software engineers around a project, an open-source framework, a competitor, or a tech thought leader — no login, no coding, no GitHub token required.

Export every record to JSON, CSV, Excel, or API.

🔓 Built for technical recruiters, dev-tool and SaaS marketers, DevRel teams, engineering founders, and market researchers who need accurate, contactable developer audiences on demand.

---

⚡ At a glance

Feature	Specification
Target Entities	Individual GitHub users (torvalds) and organizations (vercel, microsoft)
Data Enrichment	Full profile parsing (Real Name, Bio, Company, Location, Website, Email, Twitter/X)
Authentication	Token-Free by default (optional GitHub personal access token supported for high velocity)
Throughput / Speed	~150–300 enriched profiles/minute; ~1,000+ profiles/minute in username-only mode
Proxy Requirement	Datacenter proxies recommended (built-in proxy rotation and 429 auto-retry)
Deduplication	Automatic de-duplication per account (0% duplicate output guarantee)
Export Formats	JSON, CSV, Excel (XLSX), XML, Apify API, Webhooks
Pagination & Batching	1,000+ follower pagination unlocked across multiple concurrent accounts

---

🔎 Why scrape GitHub followers?

A GitHub account's followers are one of the highest-signal audiences on the internet. People who follow torvalds, vercel, or a popular framework's creator are, almost by definition, actively interested in that person, product, language, or ecosystem. That organic intent is exactly what makes GitHub follower data so valuable for developer recruitment, go-to-market strategies, and tech industry research.

The problem is that GitHub provides no native export functionality. Follower lists are paginated one manual scroll at a time, and each profile hides the details you actually care about — the developer's real name, employer, location, personal website, and contact handles — behind separate sub-pages. Collecting a few hundred by hand is tedious; collecting thousands across multiple accounts by hand is impossible. This GitHub followers scraper automates the entire pipeline: it walks each follower list page by page and enriches every single profile into one clean, spreadsheet-ready row.

Because the data is extracted exclusively from public profile fields, you get a legitimate, repeatable way to map and reach developer communities without touching private data or needing third-party databases.

Common reasons teams scrape GitHub followers:

• 🧲 Build developer lead lists for technical recruiting or B2B sales outreach from accounts your ideal software engineers already follow.
• 🛠️ Reach a competitor's developer audience — the followers of a rival dev tool are the warmest possible market for your product.
• 🚀 Map and size a community around a framework, library, language, or developer-first company.
• 📊 Find high-influence developers in an open-source niche using their own follower counts and engagement metrics.
• 🧑‍💻 Source engineers by company, location, and bio for targeted hiring in specific tech hubs.
• 🤝 Research partnerships, sponsorships, and DevRel targets within a specific programming ecosystem.
• 📇 Enrich existing contact databases with personal websites, X/Twitter handles, and verified public emails.

---

✨ What this GitHub followers scraper does

• ✅ Scrapes followers of any user or organization — enter a person (torvalds), a company org (vercel), or a profile URL (https://github.com/microsoft). Add as many accounts as you like in one run.
• ✅ Enriches every follower profile — for each follower the GitHub scraper collects name, bio, company, location, website URL, public email, and X/Twitter handle, plus follower count, following count, avatar, profile URL, and account type.
• ✅ Automatic deep pagination — walks each GitHub follower list 100 records per page and returns hundreds to thousands of de-duplicated followers per account, controlled entirely by your maxItems and maxFollowersPerAccount limits.
• ✅ Works token-free — most competing GitHub scrapers force you to create personal access tokens. This actor runs out of the box; an optional token is supported only if you wish to unlock secondary API rate tiers.
• ✅ Per-account caps — keep results balanced when scraping several big accounts simultaneously so one massive organization does not monopolize your entire limit.
• ✅ Fast username-only mode — switch enrichment off for a lightning-fast list of usernames, then re-enrich only the filtered subset you care about.
• ✅ Clean, deduplicated, flat output — one row per follower, empty fields dropped, perfectly formatted for Excel, Google Sheets, or CRM imports.
• ✅ Multiple export formats — download as JSON, CSV, Excel, or XML, or pull via the Apify API and webhooks.
• ✅ Reliable at scale — datacenter proxy rotation plus automatic retries on rate limits (HTTP 403/429) ensure large batches finish cleanly.

---

🎯 Use cases & B2B recipes

1. Technical Recruiting & Engineering Talent Sourcing

Tech recruiters and sourcers can identify engineers following specific thought leaders, programming language authors, or specialized engineering blogs. Filter the resulting dataset by location (e.g., "Berlin", "San Francisco", "Remote") and company to discover high-caliber candidates who might not be active on LinkedIn.

2. Dev-Tool & SaaS Go-to-Market Campaigns

Dev-tool marketers launching an alternative to an established tool can target developers following that project's organization on GitHub. Because these developers already use that tech stack, cold outreach featuring comparison benchmarks yields significantly higher conversion rates.

3. Open-Source Community Mapping & DevRel Outreach

Developer relations teams can analyze who is following their company's open-source repositories and maintainers. Sort by followersCount to identify influential advocates and potential speakers for community meetups and conferences.

4. Account-Based Marketing (ABM) Account Mapping

B2B sales teams targeting enterprise software companies can track which developers follow relevant technical tooling. Cross-reference company handles against your CRM account target list to identify prospective champions inside targeted engineering organizations.

5. Research & Technographic Analysis

Academic and market researchers can study developer adoption and demographic distribution across emerging technology ecosystems (e.g., AI/LLM frameworks, WebAssembly, Rust ecosystem).

---

📥 Input parameters

Every input parameter is optional — enter a GitHub account and press Start for an enriched batch of developer followers.

Field	Type	Default	Description
usernames	array of strings	["torvalds"]	The GitHub users or organizations whose followers you want. Enter a username (torvalds) or a profile URL (https://github.com/vercel). Add as many as you like.
maxItems	integer	0	Stop after collecting this many followers in total across all accounts (0 = unlimited / auto governed by account caps). Prefilled to 100 for quick runs.
maxFollowersPerAccount	integer	0	Optional cap per account — useful when scraping several accounts so one big account doesn't use your whole budget. 0 = no per-account cap.
enrichProfiles	boolean	true	On by default. Collects full profile details (name, bio, company, location, website, email, X/Twitter) for every follower. Turn off for a faster username-only list.
githubToken	string (secret)	""	Optional. Paste a free GitHub personal access token to run very large jobs faster and enrich via the GitHub REST API. Leave empty to run token-free.
proxyConfiguration	object	{ "useApifyProxy": true }	Recommended and on by default. Standard datacenter proxies are enough for this Actor.

Example Input: Multi-Account Outreach List

{
  "usernames": ["yyx990803", "gaearon", "https://github.com/sveltejs"],
  "maxItems": 600,
  "maxFollowersPerAccount": 200,
  "enrichProfiles": true,
  "proxyConfiguration": { "useApifyProxy": true }
}

Example Input: Fast Username-Only Run (1,000+ handles)

{
  "usernames": ["kentcdodds"],
  "maxItems": 1000,
  "enrichProfiles": false,
  "proxyConfiguration": { "useApifyProxy": true }
}

---

📤 Output dataset

Every follower is returned as one flat, spreadsheet-ready record. Here is a real enriched row from a fresh verification run (following torvalds):

{
  "username": "amiroff",
  "name": "Metin Emiroğlu",
  "bio": "Software craftsman enjoying developing webapps, riding a bike and playing retro games. Lead solution architect @akinon",
  "company": "Akinon",
  "location": "Istanbul",
  "websiteUrl": "https://www.amiroff.dev",
  "twitter": "amiroff",
  "followersCount": 145,
  "followingCount": 109,
  "avatarUrl": "https://avatars.githubusercontent.com/u/919?v=4",
  "profileUrl": "https://github.com/amiroff",
  "type": "User",
  "followerOf": "torvalds"
}

When a developer publishes an email address, it is extracted directly:

{
  "username": "dingyi",
  "name": "Ding Yi",
  "bio": "Independent designer & developer.",
  "company": "DEX",
  "location": "Remote",
  "websiteUrl": "http://ding.one/",
  "email": "dingyimac@gmail.com",
  "twitter": "dingyi",
  "followersCount": 376,
  "followingCount": 339,
  "avatarUrl": "https://avatars.githubusercontent.com/u/2486?v=4",
  "profileUrl": "https://github.com/dingyi",
  "type": "User",
  "followerOf": "yyx990803"
}

---

📊 Output field coverage & reference

👤 Profile & Identification Fields

Field	Type	Coverage	Description
username	string	🟢 High (100%)	The follower's unique GitHub handle / login.
name	string	🟢 High (95%+)	The developer's display name from their profile.
avatarUrl	string	🟢 High (100%)	Direct URL to their profile avatar image.
profileUrl	string	🟢 High (100%)	Direct link to their GitHub profile (https://github.com/...).
type	string	🟢 High (100%)	Account classification (User or Organization).
followerOf	string	🟢 High (100%)	Target username or organization that this user follows.

🏢 Work, Location & Social Contact Fields

Field	Type	Coverage	Description
company	string	🟡 Conditional (55%)	Current company, organization, or employer handle.
location	string	🟢 High (85%+)	Self-reported geographic location or city.
bio	string	🟡 Conditional (60%)	Profile bio / headline summary.
websiteUrl	string	🟢 High (75%)	Personal website, blog, or company homepage URL.
twitter	string	🟡 Conditional (35%)	X / Twitter handle linked to their profile.
email	string	🟡 Conditional (3–5%)	Public contact email address (when published publicly).

📈 Influence & Activity Signals

Field	Type	Coverage	Description
followersCount	integer	🟢 High (95%+)	Number of developers following this user.
followingCount	integer	🟢 High (95%+)	Number of accounts this user follows.
publicRepos	integer	🟡 Token Only	Count of public repositories (with GitHub token).
hireable	boolean	🟡 Token Only	Whether user flagged themselves open to opportunities.
createdAt	string	🟡 Token Only	Date the account was registered on GitHub.

---

🔁 Pagination & scale

The GitHub followers scraper paginates each GitHub follower list automatically. It retrieves 100 followers per page and advances page by page until it reaches your requested volume or exhausts the account's followers:

• Requesting 1,000+ followers is fully supported with zero artificial clamp down.
• Control overall volume with maxItems (0 = no limit).
• Control individual account limits with maxFollowersPerAccount when collecting across multiple targets.
• Followers are automatically de-duplicated within each target, guaranteeing 0 duplicate records per account.
• Multi-threaded worker pools enrich profiles concurrently, streaming results incrementally to the Apify dataset as each account is processed.

---

⚙️ How to use

1. Open GitHub Followers Scraper on the Apify Console.
2. In GitHub accounts (usernames), enter usernames or profile URLs (e.g., torvalds, vercel, https://github.com/microsoft).
3. Set Max followers (total) (maxItems) — leave 0 for unlimited or 100 for a fast verification run.
4. Keep Enrich follower profiles checked for full lead data.
5. Click Save & Run. Monitor live enrichment in the run log.
6. Export the resulting dataset as Excel, CSV, JSON, or XML, or connect via the Apify API into Zapier, Make, or Google Sheets.

---

💻 API & Integration examples

cURL

curl -X POST "https://api.apify.com/v2/acts/haketa~github-followers-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "usernames": ["torvalds"],
    "maxItems": 100,
    "enrichProfiles": true
  }'

Python (Apify Client)

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "usernames": ["yyx990803", "gaearon"],
    "maxItems": 200,
    "maxFollowersPerAccount": 100,
    "enrichProfiles": True
}

run = client.actor("haketa/github-followers-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"@{item['username']} ({item.get('name', 'N/A')}) | Company: {item.get('company', 'N/A')} | Location: {item.get('location', 'N/A')}")

Node.js (Apify Client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/github-followers-scraper').call({
    usernames: ['torvalds'],
    maxItems: 100,
    enrichProfiles: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} enriched GitHub followers:`);
console.table(items, ['username', 'name', 'company', 'location', 'twitter', 'followersCount']);

---

💡 Pro tips for developer outreach

• 🎯 Target Niche Repos & Authors: Sourcing followers of a specialized library (e.g., a CUDA or WebGPU creator) yields far more relevant technical leads than general mega-accounts.
• ⚖️ Balance Multi-Target Runs: Use maxFollowersPerAccount: 100 when inputting 5 different maintainers so that one viral maintainer doesn't swallow your entire quota.
• ⚡ Two-Stage Enrichment Strategy: For huge audiences (10,000+), run once with enrichProfiles: false to quickly harvest all usernames, filter by specific criteria or naming conventions, and re-enrich only the top subset.
• 📊 Filter by Influence: In Excel or Google Sheets, sort descending by followersCount to quickly identify developers with significant followings for advocacy campaigns.
• 🛡️ Respect Public Data Ethics: Ensure your outreach is personalized, professional, and compliant with applicable privacy standards (GDPR, CAN-SPAM).

---

⚙️ Token-Free vs. Authenticated Mode Comparison

Capability	Token-Free Mode (Default)	Authenticated Mode (With Personal Access Token)
Setup Complexity	Zero configuration required	Paste personal access token in githubToken
Core Fields Extracted	Username, Name, Bio, Company, Location, Website, Email, Twitter/X	All default fields + Public Repos, Hireable flag, Account Created date
Throughput / Speed	Fast (~150-250 enriched profiles/minute)	Maximum (~400-500 enriched profiles/minute)
Rate Limit Management	Automatic proxy rotation & backoff on 429/403	GitHub API rate quota (5,000 requests/hour per personal token)
Ideal For	Quick lead generation, ad-hoc research, community auditing	Large enterprise-scale data mining and continuous pipelines

---

❓ Frequently Asked Questions

Is scraping public GitHub followers legal?
Yes. This Actor accesses only publicly visible profile information that GitHub users have voluntarily made accessible on their public profiles. Be sure to comply with applicable data protection regulations (such as GDPR or CCPA) when contacting individuals.

Do I need to provide a GitHub personal access token?
No. The scraper operates completely token-free by default. An optional GitHub personal access token can be provided if you wish to query GitHub's REST API directly for very high volume scraping.

How many followers can I scrape in one run?
From a single follower to thousands of followers. Large accounts with tens of thousands of followers can be paginated deeply across pages.

Can I export followers of multiple accounts in a single run?
Yes! You can supply as many usernames or profile URLs as you wish in the usernames array. Use maxFollowersPerAccount to ensure an even distribution across all targets.

Does this consume GitHub API rate limits when token-free?
No personal token limits are touched in token-free mode. The scraper fetches public HTML profiles through rotating datacenter proxies, avoiding your personal API quotas entirely.

What happens if an account has 100,000+ followers?
GitHub's public followers endpoint supports pagination up to practical limits (typically the most recent ~10,000 followers per account). To stay within optimal run budgets, use maxFollowersPerAccount to capture targeted segments.

Are email addresses guaranteed on every row?
No. GitHub allows users to choose whether to display their email publicly. Approximately 3% to 5% of GitHub developers choose to make their email public on their profile. When available, it is extracted accurately into the email field.

Can I scrape followers of GitHub organizations as well as individual users?
Yes! Organizations like vercel, facebook, or stripe have public follower lists that can be scraped just like personal profiles.

How does the scraper handle rate limiting?
The actor uses built-in datacenter proxy rotation and automatic backoff retry logic. If GitHub returns an HTTP 429 or 403 status, the scraper rotates to a new IP and retries smoothly without failing the overall run.

Can I integrate the output into CRM tools like HubSpot or Salesforce?
Yes! You can either export the dataset directly as CSV/Excel for manual import, or use Apify's native integrations with Make, Zapier, or custom webhooks to automatically sync newly scraped developer leads directly into your sales pipelines.

---

🔗 Related Scrapers & Developer Tools

• GitHub Developer Scraper — search and enrich GitHub user profiles by programming language and location.
• GitHub Repository Scraper — extract GitHub repositories with stars, topics, and commit velocity.
• GitHub Repo Audience Scraper — scrape stargazers, forkers, and watchers of open-source projects.
• Product Hunt Launches Scraper — collect Product Hunt launches, makers, and engagement metrics.
• npm Package Scraper — extract npm packages, maintainers, and download statistics.

---

📋 Changelog

v1.2 (2026-11)

• Unlocked 1,000+ deep pagination: Removed limit bottlenecks allowing multi-page follower scraping up to tens of thousands of records.
• Incremental dataset streaming: Converted dataset writes to stream live after each target rather than holding records in memory until run termination.
• Enhanced profile parsing: Improved SVG boundary and regex detection for profile websites, social links, and public emails.
• Zero-duplicate assurance: Enforced strict per-account de-duplication across all pagination pages.

v1.1 (2026-08)

• Added support for both user and organization target accounts.
• Integrated datacenter proxy rotation and automatic rate limit retry logic.
• Added optional GitHub personal access token mode for higher API limits.

v1.0 (2026-07)

• Initial release featuring token-free follower collection and profile HTML enrichment.