# GitHub Trending Repos Scraper — Daily, Weekly, Monthly (`foxlabs/github-trending-scraper`) Actor

Scrape github.com/trending for top repositories — daily, weekly, or monthly. Filter by programming language. Get repo name, owner, description, language, stars, forks, builders. Ideal for dev intelligence, AI/ML trend tracking, VC sourcing, and developer marketing.

- **URL**: https://apify.com/foxlabs/github-trending-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## GitHub Trending & Rising Repos — Topics, Owners, Contacts

Most GitHub trending scrapers hand you a **thin list of ~20 repo names**. This one does three things they don't: it **enriches every repo from the official GitHub API** (topics, license, homepage, created & last-push dates, open issues), it scrapes the **trending developers** list, and its **discover mode searches the whole of GitHub** for rising projects — getting past the search API's hard 1,000-result cap by slicing the period into date windows.

- 📈 **Volume that actually exists** — a trending page holds only 12-22 repos (measured). Discover mode returned **2,452 unique repos in a single run** for one month of new projects.
- 🏷️ **Enriched, not just listed** — license **100%**, created & last-push dates **100%**, open issues **100%**, homepage 67%, topics 56% (measured on a live trending page)
- 👤 **Owner profiles** — company, personal site, X handle, location and follower count for each maintainer
- 🆓 **No key required** — official public endpoints; add a free GitHub token only if you want big enriched runs

### Quick start (API)

Every repo created in the last month with 50+ stars, fully enriched:

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~github-trending-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "discover", "dateFrom": "2026-07-01", "dateTo": "2026-07-31", "minStars": 50, "windowDays": 7 }'
```

Prefer no code? Open the **Input** tab, keep the defaults for today's trending list, and press **Start**.

### What you get

| Field | Type | Description |
|---|---|---|
| `fullName` / `owner` / `name` / `url` | string | The repository and its GitHub URL |
| `description` | string | Repo description |
| `language` | string | Primary programming language |
| `totalStars` / `totalForks` | number | Current totals |
| `starsInPeriod` | number | Stars gained in the trending window (trending mode) |
| `builders` | array | Contributor usernames shown on the trending card |
| `topics` | array | GitHub topics — how the project describes itself |
| `license` | string | SPDX identifier, e.g. `MIT`, `Apache-2.0` |
| `homepage` | string | Project website, when set |
| `openIssues` / `watchers` | number | Open issues and watchers |
| `createdAt` / `pushedAt` | string | First published / last commit (ISO) |
| `isArchived` / `isFork` / `defaultBranch` | bool / string | Repo state |
| `enrichmentStatus` | string | Only present when enrichment was skipped, and it says why — never a silent blank |

With **owner enrichment** on, each row also carries `ownerType`, `ownerName`, `ownerCompany`, `ownerBlog`, `ownerTwitter`, `ownerLocation`, `ownerFollowers`, `ownerPublicRepos`, `ownerUrl` — and `ownerEmail` on the rare profile that publishes one (see Data quality).

Trending-developers rows carry `username`, `displayName`, `profileUrl`, `popularRepoName` plus the same owner fields.

#### Sample output

Real rows from live runs (2026-07-31):

```json
{
  "fullName": "block/buzz",
  "url": "https://github.com/block/buzz",
  "description": "A hive mind communication platform",
  "language": "Rust",
  "totalStars": 19198,
  "totalForks": 1916,
  "starsInPeriod": 12444,
  "builders": ["wesbillman", "wpfleger96", "tlongwell-block"],
  "license": "Apache-2.0",
  "source": { "mode": "trending", "since": "weekly", "language": null }
}
```

```json
{
  "fullName": "synthetic-sciences/openscience",
  "url": "https://github.com/synthetic-sciences/openscience",
  "totalStars": 3004,
  "license": "MIT",
  "createdAt": "2026-07-03T11:20:07Z",
  "source": { "mode": "discover", "window": "2026-07-01..2026-07-07" }
}
```

Download as JSON, CSV, Excel or HTML, or read it straight from the API.

### Modes & filters

- **Trending repositories** — pick any number of **languages** and any of **daily / weekly / monthly**; every combination is a separate page. Optional spoken-language filter.
- **Trending developers** — the 25-person list, with optional profile enrichment.
- **Discover rising repos** — `minStars`, `created` vs `pushed` date, a date range, an optional language, topic or raw search qualifiers. `windowDays` controls how finely the period is sliced: smaller windows reach deeper past the 1,000-per-search cap.
- **Enrichment** — repo enrichment is on by default; owner enrichment is opt-in (one extra request per unique owner).
- **Max results** — hard cap; `0` = unlimited.

### Example inputs (copy & paste)

```jsonc
// 1) Today's trending, enriched
{ "mode": "trending", "periods": ["daily"], "enrichRepos": true }

// 2) Weekly trending across your stack
{ "mode": "trending", "languages": ["rust", "go", "typescript"], "periods": ["weekly"] }

// 3) New AI projects gaining traction this quarter
{ "mode": "discover", "topic": "llm", "minStars": 100, "dateFrom": "2026-05-01", "dateTo": "2026-07-31", "windowDays": 7 }

// 4) Actively maintained Rust projects, with maintainer contacts
{ "mode": "discover", "discoverLanguage": "rust", "dateField": "pushed", "minStars": 500, "enrichOwners": true }

// 5) Trending developers to reach out to
{ "mode": "trending_developers", "enrichOwners": true }

// 6) Deep sweep of one month, day by day
{ "mode": "discover", "dateFrom": "2026-07-01", "dateTo": "2026-07-31", "windowDays": 1, "minStars": 20, "maxResults": 0 }
```

### Use cases

- **Developer marketing / DevRel.** Find the projects rising in your category this week, then reach the maintainers through the profile fields (site, X handle, company) rather than guessing.
- **VC & scout sourcing.** Discover mode with `created` dates surfaces genuinely new repos passing a star threshold — the earliest public signal a project is working.
- **Technical recruiting.** Trending developers plus profile enrichment gives you an ordered list of people whose work is getting attention right now.
- **Competitive & ecosystem tracking.** Watch a topic (`llm`, `kubernetes`, `fintech`) week over week: what launched, what got stars, what stopped being maintained (`pushedAt`).
- **Research datasets.** Slice any period into windows and pull thousands of enriched repo records for analysis.

### Performance & cost

Pure HTTP against GitHub's public pages and official API — no browser, no proxy. Measured on the platform (2026-07-31): a trending page with enrichment took **7 seconds**; the trending developers list with profile enrichment **7 seconds**; a **2,452-row** discover sweep of one month **260 seconds**.

**Rate limits, honestly:** GitHub allows about **60 API requests per hour** without a token (and 10 searches per minute). That's fine for a trending page, but big enriched runs need a **free GitHub personal access token** (no scopes required) — it raises the limits to 5,000/hour and 30 searches/minute. Paste it in the Advanced input. When the limit is reached, rows carry an explicit `enrichmentStatus` explaining it; the Actor never fills fields with silent blanks.

### Integrations

**JavaScript** (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/github-trending-scraper').call({
  mode: 'discover', topic: 'llm', minStars: 100, dateFrom: '2026-07-01', windowDays: 7,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/github-trending-scraper").call(run_input={
    "mode": "trending", "languages": ["rust"], "periods": ["weekly"], "enrichRepos": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["fullName"], item.get("totalStars"), item.get("license"))
```

Also works with **Make / n8n / Zapier**, scheduled runs, webhooks and the **Apify MCP server**.

### Data quality (measured 2026-07-31)

| What | Result |
|---|---|
| Trending page, enriched (n=18) | repo name / language / stars / forks / stars-in-period / builders **100%** · license **100%** · created & pushed dates **100%** · open issues **100%** · homepage 67% · topics 56% · description 94% |
| Discover sweep (n=2,452, July 2026) | **2,452 / 2,452 unique** · created & pushed dates **100%** · open issues **100%** · license 72% · language 81% · topics 46% · homepage 25% · **0 rows outside the requested window** |
| Trending developers (n=25) | username **100%** · follower count **100%** · display name 96% · popular repo 96% · location 68% · personal site 64% · company 56% · X handle 48% |
| URL evidence | **10 of 10** randomly picked repo URLs loaded and matched their row |
| Search-cap workaround | verified: a single search stops at 1,000 (`HTTP 422` past it); the windowed run returned 2,452 |

**About e-mails:** GitHub profiles almost never publish one — measured **0 of 25** trending developers. Treat `ownerEmail` as a bonus, not a channel; the reliable contact points are the personal site (64%), X handle (48%) and company (56%). Fields a repo or profile doesn't publish (no topics, no license, no homepage) come back empty — that's the source, not a gap in the Actor.

### Pricing

**Pay per result** — billed per row returned, with an Apify **free tier** to evaluate. GitHub's endpoints are free, so there are no proxy or third-party costs.

### FAQ

**Where does the data come from?** [github.com/trending](https://github.com/trending) (public server-rendered pages) and the official [GitHub REST API](https://docs.github.com/rest) for enrichment and discovery.

**Why does trending only return ~20 repos?** Because that's all GitHub publishes on a trending page — measured 12 to 22 depending on language and period. Use discover mode when you need volume.

**How do you get more than 1,000 search results?** GitHub refuses to page past 1,000 results for a single search (verified: `HTTP 422`). Discover mode slices the period into windows and searches each one separately, so the ceiling applies per window rather than per run — 2,452 rows in the measured example.

**Do I need a GitHub token?** No for trending pages. Yes, practically, for large enriched runs or heavy discovery: anonymous access is ~60 requests/hour. A free token with no scopes lifts it to 5,000/hour.

**Will I get maintainer e-mails?** Rarely — see Data quality. Most maintainers keep e-mail private; the site / X / company fields are the useful contact route.

**Is scraping the trending page allowed?** It's a public page with no login or anti-bot, fetched at a polite rate, and enrichment uses the official documented API within its rate limits.

**Can I track a topic over time?** Yes — schedule discover mode weekly with a fixed `topic` and rolling dates, then diff the datasets.

**What's `starsInPeriod`?** The "stars today / this week / this month" number GitHub shows on the trending card. It only exists in trending mode.

### Troubleshooting

- **`enrichmentStatus` says rate limit** → add a free GitHub token in the Advanced input, or lower `maxResults`.
- **0 rows in discover** → widen the date range, lower `minStars`, or drop the topic filter; a narrow window plus a high star floor can genuinely match nothing.
- **A language returns 404** → use GitHub's own slug (e.g. `c%23` for C#, `jupyter-notebook`), as it appears in the trending URL.
- **Fewer rows than expected in trending** → that's the page size (12-22), not a failure. If a page yields *zero* entries the run fails loudly, because that would mean GitHub changed its markup.

### Notes, limits & legal

- Repository content and profiles belong to their authors; this Actor redistributes what GitHub publishes publicly. Not affiliated with GitHub.
- Trending pages are HTML — if GitHub restructures them the run fails with a clear message rather than returning an empty "success".
- `topics`, `license` and `homepage` are only as complete as the projects themselves (measured fills above).

### Support

Questions, a field you'd like added, or a custom build? Open the **Issues** tab, or e-mail **info@foxlabs.com.tr**. We reply fast.

*If this Actor saves you time, a ⭐ review really helps.*

### Changelog

#### 0.2 — 2026-07-31

- **Discover mode** — searches the whole of GitHub for rising repos and slices the period into date windows to get past the search API's 1,000-result cap (measured: 2,452 unique rows for one month, 0 outside the window).
- **Enrichment from the official API** — topics, license, homepage, created/pushed dates, open issues, watchers, plus optional owner profiles (company, site, X handle, location, followers).
- **Trending developers mode** — the 25-person list with optional profile enrichment.
- **Honest rate-limit + fail-loud handling** — `enrichmentStatus` explains any skipped enrichment; a trending page that parses to zero entries fails the run instead of reporting empty success.

#### 0.1 — 2026-05-20

- Initial release: github.com/trending HTML scraping by language and period.

***

Part of the **[foXLabs data platform](https://data.foxlabs.com.tr/)** — official public-data company, developer, jobs & market intelligence scrapers. Browse the full suite at **[data.foxlabs.com.tr](https://data.foxlabs.com.tr/)**.

# Actor input Schema

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

Trending repos = today's / this week's / this month's github.com/trending list (12-22 repos per page). Trending developers = the people list (25 per page). Discover rising repos = search the whole of GitHub for repos gaining stars in a date range — the high-volume mode, which gets past the API's 1,000-result cap by slicing the period into windows.

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

Trending modes. GitHub language slugs, e.g. \["python", "rust", "typescript"]. Each language is a separate trending page. Leave empty for the all-languages page.

## `periods` (type: `array`):

Trending modes. Which trending window(s) to pull — daily, weekly and/or monthly. Every language is fetched for every period selected.

## `spokenLanguage` (type: `string`):

Trending modes, optional. Two-letter code to keep only repos written in a spoken language (e.g. "en", "zh", "es"). Leave empty for all.

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

Discover mode. Only repos with at least this many stars. Lower it to catch earlier-stage projects, raise it for established ones.

## `dateField` (type: `string`):

Discover mode. Created = when the repo was first published (finds genuinely new projects). Pushed = last commit (finds actively maintained ones).

## `dateFrom` (type: `string`):

Discover mode. YYYY-MM-DD. Defaults to 90 days ago.

## `dateTo` (type: `string`):

Discover mode. YYYY-MM-DD. Defaults to today.

## `windowDays` (type: `integer`):

Discover mode. The period is sliced into windows of this many days and each window is searched separately — that's how the run gets past GitHub's 1,000-results-per-search cap. Smaller windows = deeper coverage, more requests.

## `discoverLanguage` (type: `string`):

Discover mode, optional. One language, e.g. "rust". Leave empty for all languages.

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

Discover mode, optional. A GitHub topic, e.g. "llm", "kubernetes", "fintech". Leave empty for all topics.

## `searchQuery` (type: `string`):

Discover mode, optional. Raw GitHub search qualifiers appended to the query, e.g. "license:mit forks:>10". Leave empty unless you know the syntax.

## `enrichRepos` (type: `boolean`):

Adds what the trending page doesn't show: topics, license, homepage, created & last-push dates, open issues and watchers, from the official GitHub API. Discover mode already includes these at no extra cost.

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

Adds each repo owner's (or developer's) public profile: name, company, blog, X handle, location, followers and e-mail where they made it public. One extra API request per unique owner.

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

Without a token GitHub allows ~60 API requests/hour, so enrichment stops early on big runs (rows say so in `enrichmentStatus` — never silently empty). A free personal access token with no scopes raises it to 5,000/hour and 30 searches/minute.

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

Hard cap on dataset rows. Set 0 for unlimited.

## Actor input object example

```json
{
  "mode": "trending",
  "languages": [],
  "periods": [
    "daily"
  ],
  "minStars": 50,
  "dateField": "created",
  "windowDays": 7,
  "enrichRepos": true,
  "enrichOwners": true,
  "maxResults": 200
}
```

# Actor output Schema

## `repositories` (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 = {
    "mode": "trending",
    "languages": [],
    "periods": [
        "daily"
    ],
    "minStars": 50,
    "windowDays": 7,
    "enrichRepos": true,
    "enrichOwners": true,
    "maxResults": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/github-trending-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 = {
    "mode": "trending",
    "languages": [],
    "periods": ["daily"],
    "minStars": 50,
    "windowDays": 7,
    "enrichRepos": True,
    "enrichOwners": True,
    "maxResults": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/github-trending-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "trending",
  "languages": [],
  "periods": [
    "daily"
  ],
  "minStars": 50,
  "windowDays": 7,
  "enrichRepos": true,
  "enrichOwners": true,
  "maxResults": 200
}' |
apify call foxlabs/github-trending-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=foxlabs/github-trending-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mo9uyhAUfGKcZUyKJ/builds/cwIUbJUgnlWIEENk6/openapi.json