GitHub Developer Scraper — Find Devs by Location & Language

🐙 GitHub Developer Scraper — Emails, Websites, Companies, Languages & Leads

The definitive GitHub talent and developer sourcing extractor on Apify. This high-performance GitHub developer scraper finds, filters, and extracts software engineers from GitHub by location, primary programming language, bio keywords, repository activity, and follower thresholds. Extract deeply enriched developer lead lists containing full names, professional bios, company affiliations, geographic locations, personal website URLs, public email addresses, X/Twitter handles, follower counts, and public repository statistics — completely token-free with zero authentication required.

Export structured developer talent datasets instantly to JSON, CSV, Excel, or API.

---

⚡ At a glance

Feature	Specification
Target Platform	GitHub User Search & Profiles
Search Dimensions	Programming language, city/country, bio keywords, min followers, min repos
Target Entities	Individual software developers (user), Organizations (organization), or Both
Contact Data	Public personal/work email, website URL, company name, Twitter/X username
Influence Signals	Exact follower counts, following counts, total public repositories, join date
Pagination & Depth	Unlocked 1,000+ developers via automated account-creation date sharding
Token Requirement	Optional. Runs 100% token-free; add personal token for ultra-high API concurrency
Execution Speed	~10–15 seconds for 100 developers; ~90 seconds for 500+ enriched profiles
Export Formats	Clean tabular datasets: JSON, CSV, XLSX, HTML Table, XML, Apify Webhooks

---

🔎 Why scrape GitHub developers?

GitHub is home to over 100 million software developers, constituting the most comprehensive, verifiable public directory of engineering talent in existence. Unlike traditional professional networking sites where resumes can be exaggerated, GitHub profiles showcase concrete evidence: live repositories, open-source code contributions, tech stack preferences, and peer recognition:

• 🧲 Technical Recruiting & Sourcing: Source elite software engineers across specific technologies (e.g., Rust, Go, TypeScript, Python) and regional hubs (Berlin, London, San Francisco, Bangalore) before headhunters saturate their LinkedIn inboxes.
• 🛠️ DevTool & SaaS Marketing: Reach the exact developer personas who build with your technology stack. Market developer-focused APIs, infrastructure tools, databases, and monitoring services directly to engineers who hold technical decision-making power.
• 🚀 Open Source Community & DevRel Outreach: Identify and invite high-impact contributors, open-source champions, and community speakers to developer conferences, early beta releases, and hackathons.
• 📊 Talent Intelligence & Tech Ecosystem Mapping: Quantify developer adoption trends, measure regional talent densities, and analyze developer movements across major tech enterprises.
• 💼 B2B Engineering Lead Generation: Connect with technical founders, VP of Engineering leaders, and Staff Architects through verified public websites, emails, and X/Twitter handles.

Manual developer sourcing on GitHub is notoriously tedious. Search results only display basic user handles, requiring you to manually open individual tabs, parse bio descriptions, and cross-reference personal blogs. This GitHub developer scraper automates query execution, multi-page traversal, profile parsing, and data enrichment in a single continuous workflow.

---

✨ Key features

• 🔍 Granular Multi-Criteria Filtering: Combine programming languages, geographic locations, keyword queries, minimum follower counts, and public repository thresholds without needing to learn GitHub's complex search syntax.
• 🔄 Unlocked 1,000+ Sharded Pagination: Bypasses GitHub's native 1,000-result search barrier. When you request over 1,000 developers (maxItems: 1000+ or 0), the actor automatically shards your search across account creation date windows.
• 🧑‍💻 Deep Profile Enrichment: Every result is automatically enriched with full profile details: full name, bio, company, location, personal blog/website, public email, Twitter handle, follower count, and public repos.
• 🌐 Token-Free Architecture: Operates out of the box without requiring GitHub personal access tokens or API keys. Optional token support is available for enterprise-scale runs.
• 🏢 Individuals & Organizations: Seamlessly toggle between individual software engineers (type:user), tech companies/open-source foundations (type:org), or both.
• 🔤 Smart Diacritic Normalization: Built-in character normalization prevents keyboard mismatch errors (such as Turkish dotted/dotless I), ensuring worldwide locations match properly.
• ⚡ Concurrent Profile Parsing: Built-in worker pool extracts and parses 8 profiles simultaneously with automatic IP rotation on rate limits, completing runs in seconds.

---

🎯 Use cases & applications

1. High-Performance Technical Recruiting

Build candidate pipelines of senior engineers for high-demand stacks. Search for developers located in London with language: Rust and minFollowers: 100 to produce a curated list of influential systems engineers with verifiable track records.

2. Developer Tool (DevTool) Product Marketing

If you are launching a new Go framework or TypeScript ORM, target engineers who code in those languages and maintain active public repositories. Engage them through personal websites or social links for early feedback.

3. Open Source Developer Relations (DevRel)

Identify influential open-source maintainers within your ecosystem. Invite them to test developer previews, speak at webinars, or join advisory contributor programs.

4. Technical Co-Founder & Early Hire Discovery

Startup founders can find talented local developers who build extensively in public. Filter for developers with high repository counts and personal projects in your domain.

5. Competitive Talent Intelligence

Track developer concentrations across different tech hubs and identify companies whose engineers are most actively contributing to relevant open-source repositories.

---

🧭 How to construct search queries

You can combine any of the following parameters to pinpoint your target developer segment:

Strategy	Recommended Configuration	Purpose
Regional Senior Talent	location: "Berlin", language: "Go", minFollowers: 50	Source recognized senior engineers in a specific city
Niche Domain Specialists	keyword: "machine learning", language: "Python", minRepos: 10	Find active AI/ML practitioners with public code
Global Influential Devs	language: "Rust", minFollowers: 500	Identify top open-source thought leaders globally
Open Source Organizations	keyword: "kubernetes", accountType: "organization"	Discover organizations and foundations in cloud native
Junior / Rising Talent	location: "Toronto", language: "TypeScript", minRepos: 5	Find rising developers actively building public portfolios

---

📥 Input parameters

Parameter	Type	Required	Default	Description
keyword	String	No	""	Search keywords matching developer name, username, or bio (e.g. "distributed systems", "web3").
location	String	No	""	Target city, region, or country (e.g. "San Francisco", "London", "Germany").
language	String	No	"" (Any)	Primary programming language (JavaScript, TypeScript, Python, Go, Rust, Java, C++, etc.).
minFollowers	Integer	No	0	Minimum follower count threshold to filter for influential or recognized engineers.
minRepos	Integer	No	0	Minimum number of public repositories to ensure candidate is actively publishing code.
accountType	String	No	"user"	Target account classification: "user" (Developers), "organization", or "both".
maxItems	Integer	No	100	Maximum developers to collect. Set to 0 for unlimited (automatically activates sharding for 1,000+). Prefill is 100.
githubToken	String	No	""	Optional GitHub Personal Access Token (ghp_...) for higher API rate limits on massive jobs.
proxyConfiguration	Object	No	Datacenter	Proxy configuration. Standard datacenter proxies ensure reliable, unthrottled profile scraping.

Example Input (input.json)

{
  "location": "San Francisco",
  "language": "TypeScript",
  "minFollowers": 50,
  "minRepos": 10,
  "accountType": "user",
  "maxItems": 250,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

---

📤 Output dataset schema

Every collected developer record is enriched and normalized into clean JSON format:

🏷️ Identity & profile metrics

Field	Type	Coverage	Description
username	string	🟢 High (100%)	GitHub username handle
name	string	🟢 High (~96%)	Developer's real or displayed name
bio	string	🟢 High (~80%)	Profile bio narrative and technical summary
type	string	🟢 High (100%)	Entity classification (User or Organization)
profileUrl	string	🟢 High (100%)	Full URL to the developer's GitHub profile
avatarUrl	string	🟢 High (100%)	Link to developer's profile avatar image

📍 Location & employment

Field	Type	Coverage	Description
location	string	🟢 High (~80%)	Self-reported geographic city, region, or country
company	string	🟢 High (~60%)	Current employer, organization, or freelance status

📞 Contact & web presence

Field	Type	Coverage	Description
email	string	🟡 Conditional (~12%)	Publicly published contact email address
websiteUrl	string	🟢 High (~80%)	Personal blog, portfolio, or company website
twitter	string	🟢 High (~55%)	X / Twitter handle or profile link

📊 Engineering activity & reach

Field	Type	Coverage	Description
followersCount	number	🟢 High (100%)	Total number of developers following this user
followingCount	number	🟢 High (100%)	Total number of accounts followed
publicRepos	number	🟢 High (100%)	Total count of public repositories published
hireable	boolean	🟡 Token	Boolean flag indicating if user is open to job offers
createdAt	string	🟡 Token	ISO 8601 account creation timestamp

---

📊 Sample output record

{
  "username": "alex-dev",
  "name": "Alex Mitchell",
  "bio": "Staff Infrastructure Engineer. Rust & distributed systems enthusiast. Building open source tooling.",
  "company": "@cloud-scale-inc",
  "location": "San Francisco, CA",
  "websiteUrl": "https://alexmitchell.dev",
  "email": "alex@alexmitchell.dev",
  "twitter": "alex_codes",
  "followersCount": 1840,
  "followingCount": 312,
  "publicRepos": 48,
  "type": "User",
  "avatarUrl": "https://avatars.githubusercontent.com/u/492817?v=4",
  "profileUrl": "https://github.com/alex-dev"
}

---

🚀 How to use & programmatic integration

Python Integration via Apify Client

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "location": "Berlin",
    "language": "Rust",
    "minFollowers": 25,
    "maxItems": 200
}

run = client.actor("haketa/github-developer-scraper").call(run_input=run_input)

for dev in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{dev.get('name')} (@{dev.get('username')}) - {dev.get('email') or dev.get('websiteUrl')}")

Node.js / JavaScript Integration

import { ApifyClient } from 'apify-client';

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

const run = await client.actor('haketa/github-developer-scraper').call({
    location: 'London',
    language: 'Python',
    minFollowers: 50,
    maxItems: 300,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Successfully extracted ${items.length} Python developers in London.`);

Direct REST API Export

curl -X GET "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&clean=true" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -o github_developers.csv

Webhook Workflow Automation

Stream new developer leads directly into your ATS (Greenhouse, Lever) or CRM (HubSpot, Salesforce) when extraction finishes:

{
  "event": "ACTOR.RUN.SUCCEEDED",
  "actorId": "haketa/github-developer-scraper",
  "datasetId": "your-dataset-id",
  "targetUrl": "https://api.yourcompany.com/webhooks/talent-leads"
}

---

🔒 Data Privacy & Responsible Sourcing Guidelines

When conducting developer outreach and technical recruiting using scraped GitHub intelligence, adhere to modern data stewardship best practices:

• Respect Contact Preferences: Only reach out to engineers who have voluntarily designated public contact information or stated hireable: true.
• Targeted & Personalized Outreach: Avoid generic mass-emailing. Reference specific public repositories, programming languages, or projects that align with the candidate's public portfolio.
• Provide Clear Opt-Out Mechanisms: In all communications, clearly explain why you reached out and include a straightforward way for developers to decline future messages.
• GDPR & CCPA Compliance: If sourcing candidates within the European Union or California, ensure you maintain a lawful basis for processing professional contact data (such as legitimate interest for relevant career opportunities) and honor opt-out or deletion requests promptly.
• Rate Limit Etiquette: When querying GitHub at scale, ensure proxy rotation is active to avoid placing excessive load on any single network interface.
• Data Retention Minimization: Purge outdated developer records periodically to ensure your candidate database accurately reflects current employment and location statuses.

---

📈 Sourcing Benchmark & Performance Metrics

In continuous testing across diverse technical stacks and regional geographies, the scraper demonstrates exceptional speed and data fidelity:

Query Type	Location & Language	Items Requested	Execution Time	Unique Records	Duplicate Rate
High-Density Tech Hub	San Francisco · TypeScript	100	~12 seconds	100	0.0%
Specialized European Tech	Berlin · Rust	150	~18 seconds	150	0.0%
Broad National Search	United Kingdom · Python	500	~65 seconds	500	0.0%
Sharded Deep Pagination	Worldwide · Go (minFollowers: 20)	1,500	~190 seconds	1,500	0.0%

---

⚖️ Comparison: Manual vs. In-House vs. GitHub Developer Scraper

Feature	Manual GitHub Search	In-House Custom Script	GitHub Developer Scraper (Actor)
Speed	1 profile / minute	Rate-limited quickly	100+ profiles / 15 seconds
Search Ceiling	Capped at 1,000 matches	Capped at 1,000 matches	Unlocked 1,000+ via time sharding
Token Requirement	Not applicable	Strict token quota needed	100% token-free out of the box
Profile Enrichment	Manual copy-pasting	Requires separate API calls	Fully enriched profiles by default
Data Normalization	Raw unstructured copy	Frequent schema breakage	Clean typed integers, booleans, strings

---

💡 Best practices for high-volume developer sourcing

1. Use minFollowers as a Quality Filter: Setting minFollowers: 10 or 25 eliminates dormant, empty, or bot accounts, ensuring every lead is an active participant in the developer community.
2. Combine Technology & Geography: Precision searches (e.g., location: "Amsterdam", language: "Go") yield immediate, high-conversion candidate lists for technical recruiters.
3. Scaling Beyond 1,000 Results: For nationwide or broad language searches (e.g., all Python developers in the United States), set maxItems: 2500 or 0. The actor automatically activates creation-date sharding to collect multiple thousands of profiles.
4. Supply an Optional Token for Mega-Runs: If you plan to scrape 5,000+ developers in a single execution, adding a free personal access token increases API concurrency and speed.

---

❓ Frequently Asked Questions (FAQ)

Do I need a GitHub personal access token to use this scraper?

No. The actor functions completely token-free by analyzing public profile endpoints. Supplying a free personal access token is purely optional and recommended only for massive high-volume jobs.

How does the scraper bypass GitHub's 1,000 result search ceiling?

GitHub normally restricts any single user search query to 1,000 total matches. When you configure maxItems above 1,000, this actor automatically segments your search across account creation date windows (created:<=2014, created:2015..2017, etc.), gathering up to 1,000 matches per segment and deduplicating the combined dataset.

What percentage of developers have public email addresses?

GitHub only exposes a developer's email address if they have chosen to make it publicly visible in their profile settings. Across broad datasets, public email coverage averages 10%–15%. However, over 80% of developers provide a personal website, blog, or Twitter/X handle where direct contact information is readily accessible.

What is the difference between accountType: user and organization?

Choosing user targets individual developers, engineers, and maintainers. Choosing organization targets open-source foundations, commercial developer tools, software companies, and universities that host repositories on GitHub.

How does the scraper rank developers in the output dataset?

Results are automatically sorted by follower count in descending order. This guarantees that the most influential, recognized, and actively engaged developers in any language or geographic market appear at the top of your exported dataset.

Can I search for developers by multiple languages?

Each search query filters by one primary language. To collect developers across multiple stacks (e.g. Go and Rust), run sequential tasks or configure an Apify webhook workflow to combine datasets.

Can I export directly to Microsoft Excel or Google Sheets?

Yes. The Apify Console enables direct 1-click downloads in Excel (XLSX), CSV, JSON, or XML format, as well as live syncing to Google Sheets and Airtable via Apify Integrations.

How frequently can I schedule developer sourcing runs?

You can run the actor as frequently as desired — daily, weekly, or on-demand. Since each developer record includes a unique username, you can easily upsert new profiles into your database or CRM without duplicating existing records.

How does the scraper handle users with non-English or localized names?

The scraper preserves complete UTF-8 character encoding, ensuring that names in Chinese, Japanese, Cyrillic, Arabic, or accented Latin scripts are captured without character corruption.

Can I filter specifically for active open-source contributors?

Yes. Use the minRepos parameter (e.g. minRepos: 10) combined with minFollowers: 20 to guarantee that the collected developers maintain multiple public code repositories and active community engagement.

Is there any risk of IP blocks when scraping large developer datasets?

No. The scraper incorporates automatic proxy IP rotation and adaptive backoff throttling, distributing requests across diverse network interfaces to maintain uninterrupted data collection.

---

🔗 Related developer & tech scrapers

• GitHub Repository Scraper — search repositories by topic, stars, and language
• GitHub Followers Scraper — extract follower networks and developer leads
• npm Package Scraper — extract download counts, maintainers, and dependencies
• WordPress Plugin & Theme Scraper — directory rankings, ratings, and authors
• ProductHunt Launches Scraper — makers, upvotes, and launch metrics
• GitLab Project & Contributor Scraper — GitLab open-source contributors and project leads
• Dev.to Articles & Author Scraper — developer blog authors and engagement metrics

---

📋 Changelog

Version 1.2 (2026-11)

• Deep Pagination & Search Sharding: Added automated creation-date sharding, completely removing the 1,000-developer limit and enabling 1,000+ profile harvesting.
• Fast Prefill Execution: Tuned prefill parameters to complete standard 100-developer sample runs in under 15 seconds with 0 duplicates.
• Enhanced Profile Normalization: Improved regex parsing for exact repository counters, follower counts (k/m), and social media link resolution.
• Cleaned Dataset Schemas: Standardized dataset views and validated 100% strict Apify CLI compliance.
• Documentation Overhaul: Added comprehensive SEO keyword mapping, field coverage indicators, and architecture summaries.
• Improved Rate-Limit Recovery: Enhanced automated proxy IP rotation to transparently recover from GitHub search rate limits.

Version 1.1 (2026-07)

• Added Turkish character folding (İ/I) to eliminate regional keyboard mismatch errors.
• Added optional GitHub token support for accelerated API enrichment.
• Added concurrent profile fetching with automatic proxy IP rotation.

Version 1.0 (2026-07)

• Initial production release supporting developer search by language, location, and follower metrics.