# GitHub Trending Scraper for Developer Signals (`skootle/github-trending`) Actor

Scrape GitHub Trending repositories by language and time window. Export repo names, descriptions, stars, forks, languages, owners, URLs, and agent-ready summaries for developer tooling, research, and AI monitoring.

- **URL**: https://apify.com/skootle/github-trending.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** Developer tools, AI, Automation
- **Features:** Limited permissions
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 github trending repo records

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

### Fast answer: what this Actor is for

Track developer momentum from GitHub Trending: repos, topics, stars, forks, languages, and summaries. Best for AI/devtools research and trend monitoring.

- Run it from the Apify UI for one-off exports.
- Schedule it or call it by API for recurring monitoring.
- Use the dataset output directly in spreadsheets, automations, and AI agents.

![GitHub Trending Repos hero](https://raw.githubusercontent.com/kesjam/skootle-actors-assets/main/heroes/github-trending.png)

### TL;DR

Daily, weekly, monthly trending repositories from `github.com/trending`. Returns clean structured JSON with rank, stars, stars-gained-this-period, language, contributors, plus optional GitHub REST API enrichment for license, topics, watchers, default branch, push date, and archived/fork flags. Watchlist mode emits only repos where rank or stars changed. Built on the public `github.com/trending` HTML page plus optional `api.github.com/repos/<owner>/<repo>` enrichment.

***

> Try it on a small dataset, then let us know what you think in a [review](https://apify.com/skootle/github-trending/reviews).

***

### What does GitHub Trending Repos do?

GitHub Trending Repos extracts the trending repositories from `github.com/trending` and optionally joins each repo with its full GitHub REST API metadata. You pick which trending windows to pull (`daily`, `weekly`, `monthly`), optionally filter by programming language, and the actor returns one record per repo with: full name, owner, name, URL, description, language + color, stars, forks, stars gained this period, rank, top contributors, and the API enrichment block (license, topics, watchers, default branch, push date, created/updated dates, size, archived flag, fork flag).

Watchlist mode (`watchlistMode: true`) tracks `stars` and `rank` per repo across runs and emits only repos where either changed. Schedule daily and you get a clean diff feed of what's gaining or losing momentum.

### Why scrape GitHub Trending?

GitHub Trending changes every few hours and nobody else gives it to you as structured data. Track rising projects before they hit the front page, for VC analysts on OSS-first investment targets, dev-relations teams watching category-adjacent momentum, weekly tech newsletters, AI agents tracking what new tech to learn, and recruiters mining contributor lists of fast-rising repos.

License audits and BFS-style compliance checks fall out naturally, every record carries license, topics, and archived/fork flags so a daily watchlist doubles as a compliance feed.

### Who needs this?

- **AI / LLM teams** tracking trending AI repos and benchmarks daily
- **VC and tech-scouting analysts** sourcing OSS-first acquisition or investment targets
- **DevRel teams** monitoring competitor and category-adjacent OSS momentum
- **Recruiters** mining contributor lists of fast-rising repos for top-of-funnel candidates
- **License compliance teams** auditing license types across trending dependencies
- **Technology radar / engineering leadership** spotting new frameworks before they go mainstream
- **AI agents** consuming a daily curated digest of dev innovation

### How to use GitHub Trending Repos

1. Open the **Input** tab on the actor page
2. Pick periods in the `periods` field (`daily`, `weekly`, `monthly`). One run handles many.
3. Optionally filter by language (`languages: ["python", "typescript"]`), empty means all languages combined
4. Optionally set `spokenLanguageCode` for spoken-language filter (`en`, `zh`, `ja`)
5. Optionally enable `enrichWithApi` (default `true`) for license, topics, watchers
6. Optionally provide a `githubToken` (raises GitHub API quota from ~60/h to ~5,000/h)
7. Optionally enable `watchlistMode` for daily diffs
8. Set `maxItems` (default 25)
9. Click **Start**

### How much will scraping GitHub Trending cost?

This actor is priced per event:

- **Actor Start**: $0.01 once per run
- **GitHub trending repo record**: tiered, charged per record written

| Apify plan | $/1000 records |
|---|---|
| FREE | $8.00 |
| BRONZE | $7.00 |
| SILVER | $6.00 |
| GOLD | $5.00 |
| PLATINUM | $5.00 |
| DIAMOND | $5.00 |

A typical daily watchlist on the `daily` window with API enrichment returns ~25 repos on day 1, ~5-15 per day in watchlist mode. Roughly $0.10-$0.30 per daily run on GOLD.

### Is it legal to scrape GitHub Trending?

Yes. `github.com/trending` is a public marketing page, anyone in a browser can read it. The GitHub REST API is also explicitly published with public read access (no auth required for public-repo endpoints, though authenticated requests get a higher rate limit). This actor honors both with respectful pacing.

GitHub's Acceptable Use Policy permits programmatic access to public data. The data scraped (repo names, stars, descriptions, contributor handles) is published by repo owners as marketing material specifically intended to be discoverable. Use freely for research, analytics, AI training, or commercial intelligence products.

### Examples

#### Example 1: Daily Python trending

```json
{
  "periods": ["daily"],
  "languages": ["python"],
  "enrichWithApi": true,
  "watchlistMode": true,
  "maxItems": 25
}
```

#### Example 2: AI-focused weekly trending across 4 languages

```json
{
  "periods": ["weekly"],
  "languages": ["python", "typescript", "rust", "go"],
  "enrichWithApi": true,
  "maxItems": 100
}
```

#### Example 3: Daily all-languages combined

```json
{
  "periods": ["daily"],
  "languages": [],
  "enrichWithApi": true,
  "maxItems": 25
}
```

#### Example 4: Monthly TypeScript trending with token

```json
{
  "periods": ["monthly"],
  "languages": ["typescript"],
  "enrichWithApi": true,
  "githubToken": "ghp_yourtoken",
  "maxItems": 25
}
```

#### Example 5: Star-velocity tracker (watchlist on daily)

```json
{
  "periods": ["daily"],
  "languages": ["python", "typescript"],
  "enrichWithApi": false,
  "watchlistMode": true,
  "maxItems": 50
}
```

Run hourly. Diff output gives you star velocity in near-real-time.

#### Example 6: License-compliance audit

```json
{
  "periods": ["daily", "weekly"],
  "languages": ["python", "javascript", "typescript", "go", "rust", "java"],
  "enrichWithApi": true,
  "githubToken": "ghp_yourtoken",
  "maxItems": 200
}
```

Filter the output for `enrichment.license` values; flag GPL/AGPL repos against your team's allowed-license policy.

#### Example 7: Hiring funnel from contributor lists

```json
{
  "periods": ["weekly", "monthly"],
  "languages": ["python", "typescript"],
  "enrichWithApi": false,
  "maxItems": 100
}
```

Each record carries `contributors[]` (login + avatar). Pipe to a recruiter pipeline.

#### Example 8: Spoken-language filter (Chinese-language repos)

```json
{
  "periods": ["weekly"],
  "spokenLanguageCode": "zh",
  "enrichWithApi": true,
  "maxItems": 25
}
```

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `periods` | enum\[] | `["daily"]` | `daily`, `weekly`, `monthly` |
| `languages` | string\[] | `[]` | Language slugs (`python`, `typescript`, `rust`). Empty = all combined. |
| `spokenLanguageCode` | string|null | `null` | Spoken-language filter (`en`, `zh`, `ja`) |
| `enrichWithApi` | bool | `true` | Adds 1 GitHub API call per repo |
| `githubToken` | string|null | `null` | PAT raises API quota from ~60/h to ~5,000/h |
| `watchlistMode` | bool | `false` | Diff against KV-stored last-seen rank+stars |
| `maxItems` | int | `25` | Hard cap |
| `useApifyProxy` | bool | `false` | Usually unneeded |

### GitHub Trending output format

#### `github_trending_repo`

| Field | Type | Description |
|---|---|---|
| `outputSchemaVersion`, `recordType`, `recordId` | string | Discriminated identity |
| `fullName`, `owner`, `name`, `url` | string | Repo identity + canonical URL |
| `description` | string | Tagline |
| `language`, `languageColor` | string | Primary language + color |
| `stars`, `forks`, `starsGainedThisPeriod` | int | Engagement |
| `rank`, `period` | int / enum | Position + window |
| `spokenLanguageCode`, `languageFilter` | string | Filters used |
| `contributors` | array | `[{ login, avatarUrl }]` (top 5) |
| `enrichment` | object | null | When `enrichWithApi: true`: `defaultBranch`, `license`, `homepage`, `topics[]`, `openIssues`, `watchers`, `pushedAt`, `createdAt`, `updatedAt`, `size`, `archived`, `isFork`, `htmlUrl` |
| `fieldCompletenessScore`, `agentMarkdown` | int / string | Quality + LLM-ready summary |
| `scrapedAt` | ISO 8601 | Snapshot timestamp |

#### GitHub Trending scraper output example

```json
{
  "outputSchemaVersion": "2026-05-09",
  "recordType": "github_trending_repo",
  "recordId": "github:trending:daily:anthropics/financial-services",
  "fullName": "anthropics/financial-services",
  "owner": "anthropics",
  "name": "financial-services",
  "url": "https://github.com/anthropics/financial-services",
  "language": "Python",
  "stars": 15808,
  "forks": 1988,
  "starsGainedThisPeriod": 3660,
  "rank": 1,
  "period": "daily",
  "contributors": [
    { "login": "user1", "avatarUrl": "https://avatars.githubusercontent.com/u/..." }
  ],
  "enrichment": {
    "license": "MIT",
    "topics": ["ai", "claude", "finance"],
    "watchers": 32,
    "openIssues": 12,
    "pushedAt": "2026-05-09T08:30:00Z",
    "archived": false,
    "isFork": false
  },
  "fieldCompletenessScore": 95,
  "agentMarkdown": "**🐙 anthropics/financial-services** (#1 daily · Python)\n- ⭐ 15,808 · 🔱 1,988 · 📈 +3,660 daily\n- 🏷 ai, claude, finance\n- 📜 MIT\n- 🔗 https://github.com/anthropics/financial-services"
}
```

### During the Actor run

The actor pulls trending repos and (optionally) the GitHub REST enrichment block with respectful pacing. No GitHub token required for small daily runs; pass one for higher quotas. Alongside the dataset, three artifacts land in the actor's key-value store: **`OUTPUT`** (run summary), **`AGENT_BRIEFING`** (top 10 by stars-gained), and **`WATCHLIST_STATE`** (per-repo last-seen rank + stars, when `watchlistMode: true`).

### FAQ

#### Do I need a GitHub token?

For small runs (≤25 repos with enrichment), no, GitHub's unauthenticated API allows ~60 requests/hour, which covers a daily watchlist comfortably. For larger runs, provide a GitHub personal access token (PAT); authenticated requests get ~5,000/hour.

#### Can I monitor for star/rank changes only?

Yes. Set `watchlistMode: true`. The actor tracks `stars` and `rank` per repo per run and only emits records where either changed.

#### Can I filter by programming language?

Yes. `languages: ["python", "typescript"]`. The actor pulls `github.com/trending/python?since=daily` and `github.com/trending/typescript?since=daily` separately.

#### Can I filter by README spoken language?

Yes. Set `spokenLanguageCode: "zh"` (or any ISO-639-1 code). GitHub's trending page accepts this filter.

#### Can I get the contributors of each trending repo?

Yes, the top 5 contributors visible on the trending card are emitted as `contributors[]` (login + avatar URL).

#### Can I use this with the Apify API?

Yes. POST to `https://api.apify.com/v2/acts/skootle~github-trending/runs`.

#### Can I integrate with Make / Zapier / n8n / Slack?

Yes. Click **Integrations** on the actor page.

#### What if GitHub changes the trending page layout?

The trending page format has been stable for years. If it changes, the actor adapts within 24-48 hours.

#### Your feedback

Hit a bug or want a feature? Open an issue on the [Issues tab](https://apify.com/skootle/github-trending/issues/open) rather than the reviews page, and we'll fix it fast (typically within 48 hours).

### Why choose GitHub Trending Repos

- **Monitor mode emits only what's new since last run**, only repos where stars or rank changed, so a daily cron is a clean rising-projects feed for VC scouting or weekly tech newsletters
- **All 3 windows in one actor**, daily, weekly, monthly, by language and by spoken-language, instead of refreshing github.com/trending tab by tab
- **Star-velocity ranking built in**, `starsGainedThisPeriod` per record so you can sort by momentum, not raw stars
- **API enrichment per record**, license, topics, watchers, push date, archived flag, and fork flag, so license audits and recruiter sourcing work off one dataset
- **Reliability free actors can't deliver**, free actors break when GitHub shifts the trending page layout. We auto-test daily and ship a fix within 24-48 hours
- **No proxy required**, runs are cheap and predictable for production pipelines
- **Agent-ready markdown** per record drops straight into an LLM context window
- **Re-runs are safe to dedupe by ID**, stable `github:trending:<period>:<owner>/<repo>` keys
- **Schema doesn't break your pipeline**, versioned and bumped on breaking change

### Other Skootle actors you might want to check

- **[Hacker News Watchlist](https://apify.com/skootle/hackernews-watchlist)**, same pattern for HN streams
- **[Reddit Subreddit Scraper](https://apify.com/skootle/reddit-subreddit-monitor)**, subreddit monitoring
- **[SEC EDGAR Filings Monitor](https://apify.com/skootle/sec-edgar-filings)**, public-company filings stream
- **[Apple App Store Reviews Monitor](https://apify.com/skootle/app-store-reviews)**, App Store reviews + metadata
- **[Shopify App Store Scraper](https://apify.com/skootle/shopify-app-store-scraper)**, Shopify app listings + pricing tiers

### Maintenance status

Verified on 2026-09-15: production dependencies were refreshed, then the Actor passed its TypeScript build, Apify schema validation, and a no-cache Node 20 container build with `dist/main.js` present in the image. A bounded latest-build cloud canary is the remaining deployment verification step.

### Support and contact

File issues on this actor's page, replies within 48 hours.

# Actor input Schema

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

Which trending windows to pull. One run handles many.

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

Filter by GitHub language slug (e.g., 'python', 'typescript', 'rust'). Empty = all languages combined.

## `spokenLanguageCode` (type: `string`):

Filter trending by spoken language of README. Empty = no filter.

## `enrichWithApi` (type: `boolean`):

Adds one API call per repo. Returns license, topics, watchers, push/created/updated dates, archived/fork flags.

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

Without a token, GitHub's API allows ~60 req/h. With a classic PAT, ~5000/h.

## `watchlistMode` (type: `boolean`):

When true, only emit repos where stars or rank changed since the previous run.

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

Hard cap. Default conservative for the 5-minute auto-test.

## `useApifyProxy` (type: `boolean`):

GitHub trending is HTTP-friendly; proxy usually unnecessary.

## `apifyProxyGroups` (type: `array`):

Optional. Empty unless you specifically need a proxy group.

## Actor input object example

```json
{
  "periods": [
    "daily"
  ],
  "languages": [],
  "enrichWithApi": true,
  "watchlistMode": false,
  "maxItems": 25,
  "useApifyProxy": false,
  "apifyProxyGroups": []
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

No description

## `agentBriefing` (type: `string`):

No description

## `runSummary` (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 = {
    "periods": [
        "daily"
    ],
    "languages": [],
    "apifyProxyGroups": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("skootle/github-trending").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 = {
    "periods": ["daily"],
    "languages": [],
    "apifyProxyGroups": [],
}

# Run the Actor and wait for it to finish
run = client.actor("skootle/github-trending").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 '{
  "periods": [
    "daily"
  ],
  "languages": [],
  "apifyProxyGroups": []
}' |
apify call skootle/github-trending --silent --output-dataset

```

## MCP server setup

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

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/MIlPxEDTghYKdtvV5/builds/ray5TmMHhDVtjLpOt/openapi.json