# GitHub Developer Scraper — Find Devs by Location & Language (`haketa/github-developer-scraper`) Actor

Find developers on GitHub by location, programming language, keyword and follower count. Export each enriched with name, company, location, website, email and X/Twitter. Build targeted developer and recruiting lead lists — no code or token required.

- **URL**: https://apify.com/haketa/github-developer-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Developer tools, Social media
- **Features:** Limited permissions
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 🐙 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**](https://github.com) 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**.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?style=flat-square\&logo=apify)](https://apify.com/haketa/github-developer-scraper)
[![Live Data](https://img.shields.io/badge/Data-Live%20at%20Run%20Time-orange?style=flat-square)]()
[![Platform](https://img.shields.io/badge/Platform-GitHub-black?style=flat-square\&logo=github)]()
[![Leads](https://img.shields.io/badge/Includes-Public%20Emails%20%26%20Socials-success?style=flat-square)]()
[![Languages](https://img.shields.io/badge/Languages-JS%20%C2%B7%20Python%20%C2%B7%20Rust%20%C2%B7%20Go%20%C2%B7%20All-brightgreen?style=flat-square)]()
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Sharded-purple?style=flat-square)]()
[![Export Formats](https://img.shields.io/badge/Export-JSON%20%C2%B7%20CSV%20%C2%B7%20Excel-lightgrey?style=flat-square)]()

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Platform** | [GitHub User Search & Profiles](https://github.com/search) |
| **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`)

```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

```json
{
  "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

```python
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

```javascript
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

```bash
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:

```json
{
  "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](https://apify.com/haketa/github-repository-scraper) — search repositories by topic, stars, and language
- [GitHub Followers Scraper](https://apify.com/haketa/github-followers-scraper) — extract follower networks and developer leads
- [npm Package Scraper](https://apify.com/haketa/npm-package-scraper) — extract download counts, maintainers, and dependencies
- [WordPress Plugin & Theme Scraper](https://apify.com/haketa/wordpress-directory-scraper) — directory rankings, ratings, and authors
- [ProductHunt Launches Scraper](https://apify.com/haketa/producthunt-launches-scraper) — makers, upvotes, and launch metrics
- [GitLab Project & Contributor Scraper](https://apify.com/haketa/gitlab-scraper) — GitLab open-source contributors and project leads
- [Dev.to Articles & Author Scraper](https://apify.com/haketa/devto-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.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/github-developer-scraper/changelog.md

# Actor input Schema

## `keyword` (type: `string`):

Optional. Words to match in a developer's name, username or bio — e.g. "machine learning", "devrel", "game developer". Leave empty to search by the filters below only.

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

Optional. City, region or country — e.g. "London", "Berlin", "San Francisco", "India". Leave empty for worldwide.

## `language` (type: `string`):

Optional. Only developers whose top language matches. Leave empty for any language.

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

Optional. Only developers with at least this many followers (a signal of influence). Set 0 for no minimum.

## `minRepos` (type: `integer`):

Optional. Only developers with at least this many public repositories. Set 0 for no minimum.

## `accountType` (type: `string`):

Whether to return individual developers, organizations, or both.

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

Stop after collecting this many developers. Automatically shards across creation dates when collecting 1,000+ developers. Set 0 for unlimited.

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

Optional. The Actor works without one. Add a free GitHub personal access token to run large jobs faster (GitHub → Settings → Developer settings → Personal access tokens; no special scopes needed).

## `proxyConfiguration` (type: `object`):

Recommended for reliable collection. Datacenter proxies are enough for this Actor.

## Actor input object example

```json
{
  "keyword": "machine learning",
  "location": "London",
  "language": "",
  "minFollowers": 0,
  "minRepos": 0,
  "accountType": "user",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open to view, filter and export all collected developers (JSON, CSV, Excel).

# 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 = {
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/github-developer-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 = {
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/github-developer-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 '{
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/github-developer-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/github-developer-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/uJpZXFPFsfhZgZAbd/builds/a6gRkWlaKrlcAZAho/openapi.json