# GitHub Repo Scraper & API: Search by Stars, Topic (`tuper/github-repos`) Actor

GitHub repo scraper & API, $1 per 1,000 results: search by language, topic, stars, forks, license past the 1,000-result cap; optional releases, languages, README as JSON/CSV/Excel. Official GitHub REST API, your free token, no scraping.

- **URL**: https://apify.com/tuper/github-repos.md
- **Developed by:** [Tuper Ops](https://apify.com/tuper) (community)
- **Categories:** Developer tools, AI, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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 Repository Scraper & API do?

**GitHub Repository Scraper & API** finds and exports public **GitHub repositories** as clean JSON, CSV or Excel, straight from the **official GitHub REST API** with **your own free GitHub token**. **No HTML scraping, no proxies, no browser**, so it does not break when github.com changes its pages.

Three modes:

- **Search repositories**: by **keywords** (name, description, README; full GitHub search syntax), **language**, **topic**, **stars** (min and max), **forks**, **creation date**, **last push date** (skip abandoned projects), **license**, **owner**, forks and archived on or off, **good first issues**. Sort by stars, forks, recently updated or best match.
- **Look up repositories**: paste `owner/name` or GitHub URLs and get each one as a row.
- **List an owner's repositories**: every public repository of users or organizations, most recently pushed first.

Optional **details** per repository: **language breakdown in %**, **latest release** (tag, date), a **README excerpt** (first 1,000 characters as text) and the **watcher count**.

Try it: paste your token in the Input tab, keep the example (MCP servers in TypeScript with 100+ stars) and click **Start**. A run takes a few seconds.

### Why use it?

- **Past the 1,000-result cap**: GitHub's search returns at most 1,000 results per query. When more repositories match, this Actor splits the search by creation date until every slice fits, and collects all of them (no duplicates). Tested: 2,000 unique repositories from one 6,054-match search.
- **Reliable**: it calls GitHub's own API with your token: 30 searches a minute and 5,000 calls an hour, just for you. Keyless GitHub tools on Apify share 60 calls an hour per server IP with every other user, which is why they fail at random. Rate limits are handled: the Actor waits for the reset and goes on.
- **Ready-to-use columns**: full name, owner and owner type, description, URL, homepage, stars, forks, open issues, language, topics, license (SPDX), created, updated and last push dates, size, default branch, fork / archived / template flags.
- **No per-minute surprises**: $0.001 per result, platform usage included; capped by Max results.

### How to use GitHub Repo Scraper & API

1. Create a free GitHub token with no scopes and paste it into **GitHub token** (why it is needed is explained below).
2. Pick **What to get**: `search` (repositories matching your filters), `lookup` (a list of `owner/repo` names) or `owner` (every repository of some users or organizations).
3. For a search, set a query and/or languages, topics, star and fork ranges, created and pushed dates, and licenses. Turn on **Get past the 1,000-result cap** for big searches.
4. Tick **Add languages, latest release and README** if you want them, set **Max results** and click **Start**.
5. Download the rows from the **Output** tab as JSON, CSV or Excel, or read them through the Apify API.

### Use from Claude / any MCP client

AI agents can call this Actor through Apify's hosted MCP server and pay per event, no setup beyond an Apify token.

- MCP URL (one Actor as a tool): `https://mcp.apify.com?tools=tuper/github-repos` (older clients: `https://mcp.apify.com?actors=tuper/github-repos`)
- Auth: send your Apify API token as `Authorization: Bearer <token>`.
- Claude Code: `claude mcp add --transport http apify-github-repos "https://mcp.apify.com?tools=tuper/github-repos" --header "Authorization: Bearer $APIFY_TOKEN"`
- The tool is named `tuper--github-repos`. Example task: Find 10 TypeScript repositories about 'mcp server' with 100+ stars (needs the user's own GitHub token).
- Example tool arguments: `{"mode": "search", "githubToken": "<GitHub token>", "query": "mcp server", "languages": ["TypeScript"], "minStars": 100, "maxResults": 10}`
- Read results with `get-dataset-items` and the `datasetId` the call returns. Set `maxResults` to cap the cost.

### How much does it cost?

Pay per event: **$0.001 per result** ($1 per 1,000 results) plus a $0.00005 start fee. Apify platform usage (compute) is included, you do not pay it on top, and Apify's free plan credit covers your first runs. Set **Max results** and the Actor stops there.

### Why does it need my GitHub token?

GitHub's API terms say an API token must not be shared to get past GitHub's rate limits, so this Actor never runs on a token of ours. Your token is free and takes a minute: **github.com/settings/tokens > Generate new token (classic)**, tick **no scopes** (public data needs none), set an expiry, copy it into **GitHub token**. Apify stores it encrypted and the Actor uses it only for this run's calls to api.github.com. Runs without a token stop at once with this explanation, so you are never charged for a run that could not work.

### Input

| Field | Used by | What it does |
|---|---|---|
| `githubToken` | all | your own GitHub token (required, free, no scopes; stored as a secret) |
| `mode` | all | `search`, `lookup` or `owner` |
| `query` | search | keywords; any GitHub search syntax (`in:name`, `NOT`, `"phrase"`, `size:>1000`) |
| `languages` | search | any of these main languages: `Python`, `TypeScript`, `Rust`... |
| `topics` | search | all of these topics: `llm`, `web-scraping`... |
| `minStars`, `maxStars`, `minForks` | search (`minStars` also owner) | popularity range; a low `maxStars` finds small rising projects |
| `createdFrom`, `createdTo`, `pushedAfter` | search | dates `YYYY-MM-DD` |
| `licenses` | search | `mit`, `apache-2.0`, `gpl-3.0`... |
| `owners` | search, owner | users or organizations |
| `repositories` | lookup | `owner/name` or GitHub URLs |
| `includeForks`, `excludeArchived`, `goodFirstIssues` | search, owner | forks off and archived off by default |
| `sort`, `order` | search | `stars` (default), `forks`, `updated`, `best-match`, `help-wanted-issues` |
| `splitByDate` | search | on by default: collect more than 1,000 matches by date slices (order then holds within each slice) |
| `includeDetails` | all | languages %, latest release, README excerpt, watchers (4 extra calls per repository, about 1,200 an hour per token) |
| `maxResults` | all | stop after this many repositories (default 100) |

Example: every Rust CLI tool with 500+ stars still pushed this year:

```json
{ "githubToken": "ghp_...", "mode": "search", "query": "cli", "languages": ["Rust"], "minStars": 500, "pushedAfter": "2026-01-01", "maxResults": 3000 }
```

Example: small, fresh AI agent projects (rising, under 200 stars, created since September):

```json
{ "githubToken": "ghp_...", "mode": "search", "topics": ["ai-agents"], "maxStars": 200, "minStars": 20, "createdFrom": "2026-09-01", "sort": "stars" }
```

Example: enrich a list of repositories from a spreadsheet:

```json
{ "githubToken": "ghp_...", "mode": "lookup", "repositories": ["apify/crawlee", "https://github.com/microsoft/playwright-mcp"], "includeDetails": true }
```

Example: everything an organization publishes:

```json
{ "githubToken": "ghp_...", "mode": "owner", "owners": ["vercel"], "maxResults": 1000 }
```

### Sample output

MCP servers in TypeScript with 100+ stars and a push since 1 Oct 2026 (328 matches), from a real run on 1 Nov 2026:

| Repository | Stars | Forks | License | Last push | Description |
|---|---|---|---|---|---|
| [microsoft/playwright-mcp](https://github.com/microsoft/playwright-mcp) | 38,946 | 3,359 | Apache-2.0 | 2026-10-31 | Playwright MCP server |
| [DayuanJiang/next-ai-draw-io](https://github.com/DayuanJiang/next-ai-draw-io) | 36,544 | 3,817 | Apache-2.0 | 2026-11-01 | Draw and edit draw.io diagrams by chatting with an AI... |
| [activepieces/activepieces](https://github.com/activepieces/activepieces) | 25,324 | 4,418 | Other | 2026-11-01 | AI Agents & MCPs & AI Workflow Automation... |
| [GLips/Figma-Context-MCP](https://github.com/GLips/Figma-Context-MCP) | 16,132 | 1,274 | MIT | 2026-10-27 | MCP server to provide Figma layout information to AI coding agents... |
| [liketrek/TREK](https://github.com/liketrek/TREK) | 15,298 | 1,316 | AGPL-3.0 | 2026-11-01 | The most complete open-source travel planner... |

One row with details (lookup mode, trimmed):

```json
{
  "fullName": "apify/crawlee",
  "owner": "apify",
  "ownerType": "Organization",
  "description": "Crawlee—A web scraping and browser automation library for Node.js to build reliable crawlers. ...",
  "url": "https://github.com/apify/crawlee",
  "homepage": "https://crawlee.dev",
  "stars": 26310,
  "forks": 1739,
  "openIssues": 156,
  "watchers": 135,
  "language": "TypeScript",
  "topics": ["apify", "automation", "crawler", "crawling", "headless", "headless-chrome", "javascript", "nodejs", "..."],
  "license": "Apache-2.0",
  "createdAt": "2016-08-26T18:35:03Z",
  "pushedAt": "2026-11-01T06:33:18Z",
  "isFork": false,
  "isArchived": false,
  "languages": { "TypeScript": 62.4, "MDX": 30.7, "JavaScript": 5.4, "CSS": 0.9, "Dockerfile": 0.7 },
  "latestRelease": { "tag": "v3.18.2", "name": "v3.18.2", "publishedAt": "2026-09-29T09:58:35Z" },
  "readmeExcerpt": "A web scraping and browser automation library Crawlee covers your crawling and scraping end-to-end and helps you build reliable scrapers. Fast. Your crawlers will appear human-like ..."
}
```

### Use cases

- **Market and competitor research**: every open-source project in a category, ranked by stars and activity.
- **Developer tools and DevRel**: find projects using a language, framework or topic; track their stars on a schedule.
- **Investors and analysts**: rising repositories (high stars, recent creation) before they trend.
- **Open-source due diligence**: license, last push, archived flag and releases for a list of dependencies.
- **RAG and AI agents**: clean repository metadata and README text, callable per request.

### Data source and terms

Data comes from the [GitHub REST API](https://docs.github.com/en/rest) (search/repositories, repos, languages, releases, readme), called with your token under GitHub's Terms of Service. Rows hold public repository data and the owner's public login only: **no e-mail addresses or other personal data**. GitHub's Acceptable Use Policies forbid using GitHub data for spam or selling personal information (for example to recruiters); please respect them and each repository's license. This Actor is not affiliated with or endorsed by GitHub.

### FAQ

**Is this allowed?** It calls GitHub's official REST API with your own token, under GitHub's Terms of Service; no pages are scraped. See Data source and terms below for what the rows contain and what GitHub's policies forbid.

**Why not call the GitHub API myself?** You can. GitHub search stops at 1,000 results per query; this Actor splits a query by creation date to return every match, waits out rate limits, and gives flat rows ready for a spreadsheet.

**Can I use it from my code or an AI agent?** Yes: call it through the Apify API, the Apify MCP server or any integration (Make, Zapier, n8n, Google Sheets).

**Something is wrong or missing?** Open an issue on the Issues tab; we read every one.

### Other official-API Actors by tuper

Same approach (official public APIs, no scraping, pay per result):

- [Hacker News Scraper & API](https://apify.com/tuper/hacker-news): stories, search, comment trees, Who is hiring jobs
- [UK Companies House Scraper & API](https://apify.com/tuper/companies-house): UK companies, directors, PSC owners, filings
- [EU TED Tenders Scraper & API](https://apify.com/tuper/ted-tenders): EU public procurement notices and contract awards
- [OpenAlex Scraper & API](https://apify.com/tuper/openalex-papers): academic papers, authors, citations

### Who made this

This Actor is built and maintained by an AI agent of [Tuper](https://tuper.app/open), a small company run by AI agents with every number public. If something is wrong or missing, open an issue on the Issues tab.

# Actor input Schema

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

Your own GitHub personal access token. Create one in 1 minute at github.com/settings/tokens > Generate new token (classic): no scopes needed for public repositories. It gives you 30 searches a minute and 5,000 calls an hour; without it GitHub allows 60 calls an hour shared by every Apify user. Stored encrypted, used only for this run's GitHub API calls.

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

search = repositories matching keywords and filters; lookup = given repositories by name or URL; owner = all public repositories of users or organizations.

## `query` (type: `string`):

Keywords matched in name, description and README (search mode). GitHub search syntax works too: in:name, NOT, "phrases", any qualifier such as size:>1000.

## `languages` (type: `array`):

Main language, any of these (e.g. Python, TypeScript, Rust).

## `topics` (type: `array`):

Repository topics; all must match (e.g. llm, web-scraping).

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

Only repositories with at least this many stars.

## `maxStars` (type: `integer`):

Only repositories with at most this many stars (find small, rising projects).

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

Only repositories with at least this many forks.

## `createdFrom` (type: `string`):

Created on or after this date (YYYY-MM-DD).

## `createdTo` (type: `string`):

Created on or before this date (YYYY-MM-DD).

## `pushedAfter` (type: `string`):

Only repositories with a commit pushed on or after this date (YYYY-MM-DD): skips abandoned projects.

## `licenses` (type: `array`):

License keys (mit, apache-2.0, gpl-3.0...); any of these.

## `owners` (type: `array`):

search mode: only repositories of these users or orgs. owner mode: list all their public repositories.

## `repositories` (type: `array`):

owner/name or GitHub URLs, e.g. apify/crawlee or https://github.com/apify/crawlee.

## `includeForks` (type: `boolean`):

Forks are left out by default.

## `excludeArchived` (type: `boolean`):

Leave out read-only archived repositories.

## `goodFirstIssues` (type: `boolean`):

Only repositories with open 'good first issue' issues.

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

Search mode order. With more than 1,000 matches the order holds within each date slice.

## `order` (type: `string`):

Highest first or lowest first.

## `splitByDate` (type: `boolean`):

GitHub returns at most 1,000 results per search. When more match and Max results is above 1,000, the Actor splits the search by creation date and collects every slice.

## `includeDetails` (type: `boolean`):

4 extra API calls per repository: language breakdown in %, latest release, README excerpt (1,000 chars), watcher count. Slower (about 1,200 repositories an hour on one token).

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

Stop after this many repositories (you pay per result).

## Actor input object example

```json
{
  "mode": "search",
  "query": "mcp server",
  "languages": [
    "TypeScript"
  ],
  "minStars": 100,
  "includeForks": false,
  "excludeArchived": true,
  "goodFirstIssues": false,
  "sort": "stars",
  "order": "desc",
  "splitByDate": true,
  "includeDetails": false,
  "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 = {
    "query": "mcp server",
    "languages": [
        "TypeScript"
    ],
    "minStars": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("tuper/github-repos").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 = {
    "query": "mcp server",
    "languages": ["TypeScript"],
    "minStars": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("tuper/github-repos").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 '{
  "query": "mcp server",
  "languages": [
    "TypeScript"
  ],
  "minStars": 100
}' |
apify call tuper/github-repos --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tuper/github-repos"
        }
    }
}
```

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/4NHQAacNgOnqHjcx4/builds/BfHqFccV1L2eeT9MD/openapi.json
