# GitHub Repository Scraper — Search Repos by Topic & Stars (`haketa/github-repository-scraper`) Actor

Search GitHub repositories by topic, programming language, keyword and stars. Export each with description, stars, forks, language, topics, license and homepage — plus the owner's company, location and website. Build repo datasets and developer leads, no token required.

- **URL**: https://apify.com/haketa/github-repository-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Developer tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 4 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 Repository Scraper — Stars, Topics, License & Owner Leads

**A fast, no-code [GitHub](https://github.com) repository scraper that lets you search repositories by topic, programming language, keyword and star count, then export every match with its description, stars, forks, topics, license and homepage — plus the owner's name, company, location, website and public email.** Use this **GitHub scraper** to build a clean repository dataset *and* a developer lead list in a single run — no login, no coding, no API key to manage. Whether you want to **scrape GitHub** for the top projects in a niche or turn a topic search into a technographic outreach list, this tool does both.

Export to **JSON, CSV, Excel, or API**.

> Built for market and trend researchers, dev-tool and SaaS marketers, technical recruiters, founders, investors, and partnerships/BD teams who need structured **GitHub data** at scale.

***

### 🔎 Why scrape GitHub?

[GitHub](https://github.com) is the single largest index of open-source software on the planet — tens of millions of public repositories tagged by **topic**, **language**, **stars**, **forks** and license. Behind every repository is an owner (a developer or an organization) with a public profile. That combination makes **GitHub data** uniquely valuable: it is both a map of what technology is being built and a directory of the people and companies building it.

Collecting this by hand is slow and brittle. GitHub's web search paginates 10 or 30 results at a time, the owner details (company, location, website, email) live on a separate profile page, and there is no "Export to Excel" button. Copy-pasting a few hundred repositories and then visiting each owner's profile is hours of tedious work — and it goes stale the moment a project gains stars or an owner updates their bio.

This **GitHub scraper** automates all of it. Set a few friendly filters, press **Start**, and get a flat, de-duplicated, spreadsheet-ready dataset where each row is one repository *with* its owner enriched in-line.

**Common reasons people scrape GitHub:**

- 📊 **Track the top projects** in a topic or language and watch how stars, forks and activity change over time.
- 🧲 **Generate developer leads** — turn a topic or keyword search into an outreach list complete with company, location, website and X/Twitter.
- 🧑‍💻 **Source technical talent** by finding the maintainers of notable repositories in a stack you hire for.
- 🚀 **Spot rising open-source projects** early by sorting active repositories with a star floor.
- 🤝 **Build integration and partnership target lists** of projects and companies working in your category.
- 🔬 **Run ecosystem and competitor research** — how large is a technology's footprint, who leads it, which licenses dominate.
- 📈 **Feed dashboards and models** with fresh repository metrics on a schedule.

***

### ✨ What this GitHub scraper does

- ✅ **Flexible search** — combine any of **keyword**, **topic**, **programming language**, **minimum stars** and **minimum forks** to target exactly the repositories you want. Leave everything empty to pull a sample of the most-starred repositories on GitHub.
- ✅ **Automatic pagination** — the actor walks GitHub search page by page and returns **hundreds to a full 1,000 de-duplicated repositories** per filter set (GitHub's search limit), controlled by the `maxItems` input.
- ✅ **Rich repository fields** — for every repository you get `repoFullName`, `description`, `repoUrl`, `homepage`, `stars`, `forks`, `watchers`, `openIssues`, `language`, `topics`, `license`, `createdAt`, `updatedAt`, `pushedAt` and an `archived` flag.
- ✅ **Owner enrichment (developer leads)** — optionally append each owner's `ownerName`, `ownerCompany`, `ownerLocation`, `ownerWebsite`, `ownerEmail`, `ownerTwitter`, `ownerFollowers`, `ownerType` and `ownerProfileUrl`, so a repository list doubles as a lead list.
- ✅ **Ranking** — sort by **most stars**, **most forks**, or **recently updated**.
- ✅ **Clean, flat output** — one row per repository, empty fields omitted, duplicates removed within each run; drops straight into a spreadsheet or database.
- ✅ **No token required** — the **GitHub scraper** works out of the box. A free personal access token is optional and only speeds up very large jobs.
- ✅ **Fast & reliable** — a lightweight HTTP scraper with retry, back-off and datacenter proxy rotation; owner enrichment runs concurrently.
- ✅ **Any export** — JSON, CSV, Excel, XML, or straight to Google Sheets, Airtable, a webhook, or the Apify **GitHub API**.

***

### 🎯 Use cases

- 🛠️ **Dev-tool & SaaS marketing** — find active projects in your category and the developers behind them, then reach out with company, website and email context.
- 🧲 **Technical recruiting** — build a sourcing list of maintainers of popular repositories in Python, Rust, Go or any stack, with location and follower counts to prioritize.
- 📊 **Market & trend research** — snapshot the leading projects in `machine-learning`, `fintech`, `nextjs` or any topic and re-run on a schedule to track momentum.
- 🚀 **Investors & founders** — surface rising open-source projects and the companies or individuals who own them before they are obvious.
- 🤝 **Partnerships & BD** — compile integration targets by finding every notable project in an ecosystem plus its owner's company and website.
- 🏢 **Technographic sales intelligence** — map which organizations maintain which open-source projects to enrich your ICP and account lists.
- 🔬 **Open-source ecosystem analysis** — measure license distribution, language mix, star/fork concentration and archival rates across a topic.
- 📈 **Data & analytics teams** — keep a warehouse table of repository metrics fresh via scheduled runs and the API.

***

### 📥 Input

Every field is optional — fill in any combination of filters and press **Start**. Leave them all empty and the scraper returns a sample of the most-starred repositories on GitHub.

| Field | Type | Description |
| :-- | :-- | :-- |
| `keyword` | string | Words to match in a repository's name, description or README — e.g. `payment gateway`, `chatbot`, `kubernetes operator`. |
| `topic` | string | A GitHub topic tag — e.g. `machine-learning`, `nextjs`, `fintech`. |
| `language` | string (enum) | Restrict to repositories whose **main language** matches (JavaScript, TypeScript, Python, Go, Rust, and more). Empty = any language. |
| `minStars` | integer | Only repositories with at least this many stars. `0` = no minimum. |
| `minForks` | integer | Only repositories with at least this many forks. `0` = no minimum. |
| `sort` | string (enum) | Order results by `stars`, `forks` or `updated`. |
| `enrichOwners` | boolean | Add each owner's name, company, location, website, email and X/Twitter. On by default; turn off for a faster repositories-only list. |
| `maxItems` | integer | How many repositories to collect. GitHub search returns up to **1,000** matches per filter set. `0` = maximum. |
| `githubToken` | string (secret) | Optional free personal access token to speed up large jobs. No special scopes needed. |
| `proxyConfiguration` | object | Proxy settings. Datacenter proxies are enough; Apify Proxy is on by default. |

#### Example input

```json
{
  "topic": "machine-learning",
  "language": "Python",
  "minStars": 500,
  "sort": "stars",
  "enrichOwners": true,
  "maxItems": 200,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### 📤 Output

Every repository is one flat, spreadsheet-ready row, including its owner. Only fields that have a value are included, so your export stays clean.

#### Sample output item

```json
{
  "repoFullName": "huggingface/transformers",
  "ownerUsername": "huggingface",
  "ownerType": "Organization",
  "description": "🤗 Transformers: state-of-the-art Machine Learning for PyTorch, TensorFlow and JAX.",
  "repoUrl": "https://github.com/huggingface/transformers",
  "homepage": "https://huggingface.co/transformers",
  "stars": 168131,
  "forks": 34976,
  "watchers": 168131,
  "openIssues": 1005,
  "language": "Python",
  "topics": "deep-learning, machine-learning, nlp, pytorch, transformers",
  "license": "Apache-2.0",
  "createdAt": "2018-10-29T13:56:00Z",
  "updatedAt": "2026-10-25T12:47:54Z",
  "pushedAt": "2026-10-25T10:30:17Z",
  "ownerName": "Hugging Face",
  "ownerCompany": "Hugging Face",
  "ownerLocation": "NYC + Paris",
  "ownerWebsite": "https://huggingface.co",
  "ownerTwitter": "huggingface",
  "ownerFollowers": 60000,
  "ownerProfileUrl": "https://github.com/huggingface"
}
```

#### Field reference

| Field | Description |
| :-- | :-- |
| `repoFullName` | `owner/repo` identifier. |
| `ownerUsername` | Owner's GitHub username/login. |
| `ownerType` | `User` or `Organization`. |
| `description` | Repository description. |
| `repoUrl` | Repository URL. |
| `homepage` | The project's website, when set. |
| `stars` | Star count. |
| `forks` | Fork count. |
| `watchers` | Watcher count. |
| `openIssues` | Open issues count. |
| `language` | Main programming language. |
| `topics` | Topic tags, comma-separated. |
| `license` | SPDX license ID (e.g. `MIT`, `Apache-2.0`); omitted when none/unspecified. |
| `createdAt` / `updatedAt` / `pushedAt` | Creation, last-updated and last-push timestamps (ISO 8601). |
| `archived` | `true` when the repository is archived (omitted otherwise). |
| `ownerName` | Owner's display name. *(enrichment)* |
| `ownerCompany` | Owner's company. *(enrichment)* |
| `ownerLocation` | Owner's location. *(enrichment)* |
| `ownerWebsite` | Owner's website/blog. *(enrichment)* |
| `ownerEmail` | Owner's public email, when available. *(enrichment)* |
| `ownerTwitter` | Owner's X / Twitter handle. *(enrichment)* |
| `ownerFollowers` | Owner's follower count. *(enrichment)* |
| `ownerProfileUrl` | Owner's GitHub profile URL. |

Fields marked *(enrichment)* appear only when `enrichOwners` is on and the owner has made that detail public. Public emails in particular are only present when the owner has chosen to expose one — website, company and location are far more common.

***

### 🔁 Pagination & scale

GitHub's search API returns results in pages, and it caps any single query at **1,000 matches**. This **GitHub scraper** handles that for you: it requests 100 repositories per page and walks up to 10 pages, stopping as soon as it reaches your `maxItems` target or the last page of results. You simply set `maxItems` (or `0` for the maximum) — there is no manual page handling.

Because the 1,000-result ceiling is imposed by GitHub, the way to go **wider than 1,000** is to run several narrower searches. Split a broad query by **language**, by **star range** (e.g. `minStars: 1000` then `minStars: 100` with a different sort), or by **topic**, and combine the exports. Results are de-duplicated by `repoFullName` within each run, so overlapping filters won't create duplicate rows in a single dataset.

Repository search is fast; most of the wall-clock time in a large job is owner enrichment, which runs with concurrency and retry to stay quick and resilient. Adding an optional **GitHub token** raises your rate limit and speeds up very large runs.

***

### ⚙️ How to use

1. **Open the actor** on the Apify Console.
2. **Set your filters** — any combination of `keyword`, `topic`, `language`, `minStars`, `minForks`, and choose a `sort`. Leave everything empty for the most-starred repositories.
3. **Choose `maxItems`** (up to 1,000 per filter set) and decide whether to keep `enrichOwners` on for lead data.
4. **Press Start.** Watch progress in the run log and the live status message.
5. **Preview** results in the **Output** tab, then **Export** to Excel, CSV, JSON or XML.
6. **Automate it** — call the actor via the Apify **GitHub API**, run it on a **Schedule**, or pipe results into **Make**, **Zapier**, **n8n**, **Google Sheets**, **Airtable** or your own app with a webhook.

***

### 💡 Tips

- 🎯 **Stack your filters.** Combining `topic` + `language` + `minStars` gives the most focused, highest-quality list.
- 🔁 **Go beyond 1,000** by running several targeted searches (per language, per star band, per topic) and merging the exports — dedupe is automatic within each run.
- 🧑‍💻 **Keep `enrichOwners` on** when you want leads; turn it **off** for a faster, repositories-only metrics pull.
- ⭐ **Sort by `updated`** with a star floor to catch active, rising projects instead of only established giants.
- 🏷️ **Lowercase topics** — topic tags are matched in lowercase (the scraper handles this for you), so `Machine-Learning` and `machine-learning` behave the same.
- 🔑 **Add a free GitHub token** for very large or frequently scheduled jobs to lift the rate limit.

***

### ❓ FAQ

**Is scraping GitHub legal?**
This **GitHub scraper** collects only publicly available information — the same data anyone can see on github.com without logging in — for legitimate research, recruiting and lead generation. You are responsible for complying with applicable laws (such as GDPR and CCPA), GitHub's terms, and anti-spam rules when you contact anyone.

**Do I need a GitHub token or to log in?**
No. The actor runs fully without a token or login. A free personal access token is optional and only raises your rate limit for very large jobs.

**How many repositories can I scrape, and how fast?**
GitHub search returns up to **1,000 matches per filter set**, and the scraper paginates through them automatically. A typical few-hundred-repository run completes in well under a minute; large runs are dominated by owner enrichment, which runs concurrently. To collect more than 1,000, run several narrower searches.

**Do I need proxies?**
Datacenter proxies are enough and Apify Proxy is enabled by default — no residential proxies required. Proxy rotation plus retry/back-off keeps collection reliable.

**What export formats are supported?**
JSON, CSV, Excel, and XML, plus direct integrations with Google Sheets, Airtable, webhooks, and the Apify API.

**Is there an API?**
Yes. Every actor on Apify is callable via the **GitHub API** on the platform — start runs, pass the same input, and fetch the dataset programmatically.

**How fresh is the data?**
It is pulled live from GitHub on every run. Schedule the actor to refresh your repository and lead lists daily, weekly or monthly.

**Can I filter by topic, language or stars?**
Yes — that is exactly what the input is for. Combine `topic`, `language`, `minStars`, `minForks` and `keyword`, and sort by stars, forks or recent activity.

**Are owner emails always included?**
No. Emails appear only when an owner has made theirs public. Website, company and location are far more commonly available.

**Will I get duplicate repositories?**
No. Results are de-duplicated by `repoFullName` within each run.

***

### 🔗 Related scrapers

- [GitHub Developer Scraper](https://apify.com/haketa/github-developer-scraper)
- [GitHub Repo Audience Scraper](https://apify.com/haketa/github-repo-audience-scraper)
- [GitHub Followers Scraper](https://apify.com/haketa/github-followers-scraper)
- [Product Hunt Launches Scraper](https://apify.com/haketa/producthunt-launches-scraper)
- [WordPress Directory Scraper](https://apify.com/haketa/wordpress-directory-scraper)
- [npm Package Scraper](https://apify.com/haketa/npm-package-scraper)

***

**Ready to build your repository dataset and developer lead list?** Set your filters and click **Start** to run the **GitHub Repository Scraper** now.

# Actor input Schema

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

Optional. Words to match in a repository's name, description or README — e.g. "payment gateway", "chatbot", "kubernetes operator". Leave empty to search by the filters below only.

## `topic` (type: `string`):

Optional. A GitHub topic tag — e.g. "machine-learning", "nextjs", "fintech". Leave empty for any topic.

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

Optional. Only repositories whose main language matches. Leave empty for any language.

## `minStars` (type: `integer`):

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

## `minForks` (type: `integer`):

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

## `sort` (type: `string`):

How to order the results.

## `enrichOwners` (type: `boolean`):

Add each owner's name, company, location, website, public email and X/Twitter — great for turning repositories into developer leads. Turn off for a faster repositories-only list.

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

How many repositories to collect. GitHub search returns up to 1,000 matches per set of filters. Set 0 for the maximum.

## `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": "chatbot",
  "topic": "machine-learning",
  "language": "",
  "minStars": 0,
  "minForks": 0,
  "sort": "stars",
  "enrichOwners": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Open to view, filter and export all collected repositories and their owners (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-repository-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-repository-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-repository-scraper --silent --output-dataset

```

## MCP server setup

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