# GitHub Followers & Following Scraper (`devil_port369-owner/github-follower-following-scraper`) Actor

Scrape public GitHub followers and following lists without a token. Paginated user rows with profile URL, avatar, type, and site admin flag. Linear JSON for network and outreach research.

- **URL**: https://apify.com/devil\_port369-owner/github-follower-following-scraper.md
- **Developed by:** [DataFusionX](https://apify.com/devil_port369-owner) (community)
- **Stats:** 2 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

### What does GitHub Follower/Following Scraper do?

**GitHub Follower/Following Scraper extracts the full followers or following list for any public GitHub user, returning structured profile data for each connection.** It's designed for growth marketers, community managers, and researchers mapping developer social networks on GitHub. Unlike manually paginating through a user's followers tab, this Actor batches multiple usernames per run and lets you choose whether to pull followers, following, or both — all without a GitHub personal access token.

### Why scrape GitHub followers/following? (Business Use Cases)

- **Community & Audience Mapping** — Understand who follows influential developers or maintainers to identify engaged community members for outreach or ambassador programs.
- **Lead Generation** — Build targeted prospect lists of developers following specific high-profile accounts relevant to your product's audience.
- **Network Graph & Social Research** — Construct developer social graphs to study influence, clustering, and information flow within open-source communities.
- **Competitive Audience Analysis** — See who follows competitor founders or DevRel accounts to benchmark community reach and overlap.

### Key Features

- Supports both usernames and full profile URLs as input, mixed freely
- Toggle between `followers` or `following` or `both` modes in a single configuration
- Configurable `maxResults` per user, or unlimited (`0`) for complete lists
- Returns full connection profile metadata, not just usernames
- Structured JSON output ready for CSV, Excel, or graph-analysis tools
- Efficient handling of high-follower accounts without manual pagination

### Input Parameters

| Parameter | Type | Required | Default | Description                                                                                    |
| --- | --- | --- | --- |------------------------------------------------------------------------------------------------|
| `usernames` | Array of strings | Yes | — | List of GitHub usernames or profile URLs to scrape connections for                             |
| `mode` | String | Yes | — | Either `"followers"` or `"following"` or `"both"`, determines which connection list is scraped |
| `maxResults` | Integer | No | `0` | Maximum number of connections to return per user; `0` means no limit                           |

Valid input sample:

```json
{
  "usernames": [
    "octocat",
    "https://github.com/torvalds"
  ],
  "mode": "followers",
  "maxResults": 0
}
```

### Output Data Structure

Each output item represents one follower/following relationship, tagged with the source account, the relation type, and the connected user's profile metadata.

```json
[
  {
    "source_username": "torvalds",
    "relation": "follower",
    "username": "sprsquish",
    "id": 206,
    "type": "User",
    "site_admin": false,
    "html_url": "https://github.com/sprsquish",
    "scraped_at": "2026-09-15T05:12:56.620967+00:00"
  }
]
```

### How to use GitHub Follower/Following Scraper

1. Configure `usernames`, `mode` (`followers` or `following`), and optionally `maxResults`.
2. Click "Start" or trigger a run via the Apify API, Python, or JavaScript SDK.
3. Preview the resulting connections dataset in the Apify Console.
4. Export to JSON, CSV, or Excel, or route it into Zapier, Webhooks, or Google Drive.

### Integrations & Export Options

Native export to JSON, CSV, Excel, and XML, plus direct compatibility with n8n, Zapier, and Make automation flows. Connect the dataset to database pipelines (Postgres, BigQuery, Airtable) or trigger downstream workflows via webhooks whenever a run completes.

### Custom Scrapers & Enterprise Automation Solutions

> Need a customized scraping solution, tailored workflow automation, or enterprise data extraction pipeline? Get custom development, maintenance, and setup tailored to your exact infrastructure requirements:
> 📬 **[Submit Your Custom Automation Requirements](https://mk1995.github.io/contact/)**

### Frequently Asked Questions (FAQ)

**1. Is scraping GitHub followers/following data legal and compliant?**
Follower and following lists are public on GitHub, but usage involving personal data should still be reviewed against GitHub's Terms of Service and applicable privacy regulations like GDPR, particularly for outreach use cases.

**2. How much does it cost to scrape GitHub followers using this Actor?**
Cost is based on Apify compute units consumed, which scales with the number of users and connections fetched — generally low-cost even for accounts with tens of thousands of followers.

**3. Do I need proxies or coding skills to run this scraper?**
No. Configuration happens entirely through the Apify Console's input form — no proxies or coding required.

**4. How does this compare to the official GitHub API?**
GitHub's API paginates followers/following in batches of up to 100 per request and enforces rate limits without authentication. This Actor automates that pagination across multiple users in a single run.

# Actor input Schema

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

Users whose followers and/or following lists to scrape.

## `mode` (type: `string`):

Which lists to scrape.

## `maxResults` (type: `integer`):

Max users per list (followers or following). 0 = all pages.

## Actor input object example

```json
{
  "usernames": [
    "octocat",
    "https://github.com/torvalds"
  ],
  "mode": "followers",
  "maxResults": 100
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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": [
        "octocat",
        "https://github.com/torvalds"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("devil_port369-owner/github-follower-following-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": [
        "octocat",
        "https://github.com/torvalds",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("devil_port369-owner/github-follower-following-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": [
    "octocat",
    "https://github.com/torvalds"
  ]
}' |
apify call devil_port369-owner/github-follower-following-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,devil_port369-owner/github-follower-following-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/AEWgFaJnUo6yDHZfb/builds/fXgBfN8zSCEfs93Ue/openapi.json