# GitHub Followers Scraper — Developer Leads (`haketa/github-followers-scraper`) Actor

Export the followers of any GitHub user or organization, enriched with name, bio, company, location, website, email and X/Twitter. Build targeted developer and recruiting lead lists — just enter an account, no code or token required.

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

## Pricing

from $1.50 / 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 Followers Scraper — Export Developer Leads (Name · Company · Location · Email · X)

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?logo=apify)](https://apify.com/haketa/github-followers-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/github-followers-scraper)
[![Build Status](https://img.shields.io/badge/Build-Passing-brightgreen.svg)](https://apify.com/haketa/github-followers-scraper)
[![Data Formats](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/github-followers-scraper)
[![Keyless](https://img.shields.io/badge/GitHub%20Token-Optional-success)](https://apify.com/haketa/github-followers-scraper)

**Turn any GitHub account's followers into an enriched developer lead list.** This **GitHub followers scraper** takes any [GitHub](https://github.com) **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

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

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

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

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

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

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

```javascript
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](https://apify.com/haketa/github-developer-scraper) — search and enrich GitHub user profiles by programming language and location.
- [GitHub Repository Scraper](https://apify.com/haketa/github-repository-scraper) — extract GitHub repositories with stars, topics, and commit velocity.
- [GitHub Repo Audience Scraper](https://apify.com/haketa/github-repo-audience-scraper) — scrape stargazers, forkers, and watchers of open-source projects.
- [Product Hunt Launches Scraper](https://apify.com/haketa/producthunt-launches-scraper) — collect Product Hunt launches, makers, and engagement metrics.
- [npm Package Scraper](https://apify.com/haketa/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.

# Changelog

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

# Actor input Schema

## `usernames` (type: `array`):

The GitHub users or organizations whose followers you want. Type a username (e.g. "torvalds") or paste a profile URL (e.g. https://github.com/vercel). Add as many as you like.

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

Stop after collecting this many followers in total across all accounts. Set 0 for no limit.

## `maxFollowersPerAccount` (type: `integer`):

Optional cap per account — handy when scraping several accounts at once. Set 0 for no per-account cap.

## `enrichProfiles` (type: `boolean`):

Collect full details for every follower — name, bio, company, location, website, public email and X/Twitter. Turn off for a faster username-only list.

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

Optional. Paste a free GitHub personal access token to run larger jobs faster. Leave empty to run without one.

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

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

## Actor input object example

```json
{
  "usernames": [
    "torvalds",
    "vercel",
    "https://github.com/microsoft"
  ],
  "maxItems": 100,
  "maxFollowersPerAccount": 0,
  "enrichProfiles": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Open to view, filter and export all collected followers (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 = {
    "usernames": [
        "torvalds"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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