# GitHub Trending Scraper (`fetch_cat/github-trending-scraper`) Actor

Scrape GitHub Trending repositories by language and time window for developer research, newsletters, and market intelligence.

- **URL**: https://apify.com/fetch\_cat/github-trending-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 trending repository saveds

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/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 Scraper

Track public GitHub Trending repositories by language and time window. The actor saves ranked repositories, descriptions, languages, stars, forks, stars gained, contributor avatars, and optional README text so you can monitor fast-moving developer ecosystems without copying pages by hand.

### At a glance

- **Best for:** open-source trend monitoring, developer relations, newsletter research, market intelligence, and technical ecosystem tracking.
- **Inputs:** GitHub languages, trending time window, maximum repositories, optional README enrichment, and proxy settings.
- **Outputs:** one row per trending repository with rank, owner, repo, URL, description, language, stars, forks, stars gained, contributors, source URL, and timestamp.
- **Exports:** download CSV, JSON, Excel, XML, RSS, or use the Apify Dataset API.
- **Cost:** `$0.005` per run plus the `item` event for each saved repository row.

### Input recipes

- **Daily Python snapshot:** `{"languages":["python"],"since":"daily","maxItems":10}`
- **Weekly JavaScript snapshot:** `{"languages":["javascript"],"since":"weekly","maxItems":10}`
- **Monthly overall snapshot:** `{"languages":[],"since":"monthly","maxItems":15}`
- **Small README-enriched snapshot:** `{"languages":["python"],"since":"daily","maxItems":3,"includeReadme":true}`

Verified public examples will be added here only after their saved tasks are created and pass on the final published build.

### What can it do?

- **Scrape overall GitHub Trending:** collect the public overall Trending page for daily, weekly, or monthly windows.
- **Scrape language-specific trends:** track JavaScript, Python, TypeScript, Go, Rust, and other GitHub language pages.
- **Export repository metrics:** save repository names, owners, URLs, descriptions, languages, stars, forks, and stars gained.
- **Collect contributor hints:** save public contributor avatars and profile links shown on Trending cards.
- **Enrich with README text:** optionally fetch public README text for smaller research or classification runs.
- **Build a repeatable trend monitor:** schedule the same input and compare saved datasets across runs.

### Who is it for?

This actor is useful for several teams:

- **Developer-relations teams:** track projects that are suddenly gaining attention.
- **Content teams:** build newsletters and research queues around open-source tools.
- **VC and market-intelligence teams:** discover emerging developer infrastructure and ecosystems.
- **Recruiting teams:** watch active projects and technical communities.
- **Product teams:** monitor competing frameworks, SDKs, and AI tools.
- **Data teams:** build repeatable GitHub trend dashboards.

### Why use it?

GitHub Trending is easy to view once, but hard to monitor reliably over time. This actor turns the page into structured rows that can be exported, scheduled, and connected to your workflows.

Use it when you need:

- Repeatable snapshots of trending repositories
- Language-specific open-source discovery
- A clean dataset instead of screenshots or pasted HTML
- Automation that can run daily, weekly, or monthly
- Fields that are ready for spreadsheet, BI, CRM, or alerting workflows

### Output fields

| Field | Description |
| --- | --- |
| `rank` | Repository rank on the requested Trending page |
| `owner` | GitHub owner or organization |
| `repo` | Repository name |
| `fullName` | `owner/repo` value |
| `repoUrl` | Public GitHub repository URL |
| `repositoryDescription` | Repository description shown on Trending |
| `language` | Primary language shown on Trending |
| `stars` | Total stargazers count |
| `forks` | Total forks count |
| `starsGained` | Stars gained in the selected time window |
| `builtBy` | Public usernames, profile URLs, and avatar URLs shown by GitHub |
| `since` | Requested time window |
| `trendingLanguage` | Requested language or `overall` |
| `trendingUrl` | Source Trending URL |
| `scrapedAt` | Timestamp when the row was saved |
| `snapshotKey` | Stable identity for the repository within the selected language and time window |
| `source` | `github-trending-html`, the public source that supplied this ranking |
| `parserVersion` | Parser version that produced the snapshot |
| `readmeUrl` | README URL when enrichment is enabled |
| `readmeText` | README text when enrichment is enabled |
| `readmeTruncated` | Whether README text was shortened |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `apify-actor-start` | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per GitHub Trending repository saved to the dataset. | $0.0619 / 1,000 | $0.0538 / 1,000 | $0.042 / 1,000 | $0.0323 / 1,000 | $0.0215 / 1,000 | $0.0151 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Quick start

1. Open the actor on Apify.
2. Choose one or more languages, or leave the language list empty for overall Trending.
3. Select `daily`, `weekly`, or `monthly`.
4. Set `maxItems`.
5. Keep `includeReadme` disabled for the fastest first run.
6. Start the actor.
7. Download the dataset as JSON, CSV, Excel, or via API.

### Input configuration

| Setting | JSON key | What it does |
| --- | --- | --- |
| GitHub languages | `languages` | Array of GitHub language names or slugs such as `javascript`, `python`, `typescript`, `go`, or `rust`. Leave empty for overall Trending. |
| Resume pending languages | `resumePendingLanguages` | Optional list copied from `PENDING_SCOPES.pendingLanguages` after a deadline cutoff. It replaces `languages` for that recovery run. |
| Time window | `since` | Choose `daily`, `weekly`, or `monthly`. |
| Maximum repositories | `maxItems` | Maximum repositories to save across all requested pages. Use a small number for quick tests. |
| Include README text | `includeReadme` | Fetches public README text from common README paths. This adds extra requests, so keep it off unless you need text enrichment. |
| Proxy configuration | `proxyConfiguration` | Optional proxy settings. Most runs should work without proxy because GitHub Trending is public. |

### Example input

```json
{
  "languages": ["javascript", "python", "typescript"],
  "since": "daily",
  "maxItems": 30,
  "includeReadme": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Example output item

```json
{
  "rank": 1,
  "owner": "sveltejs",
  "repo": "svelte",
  "fullName": "sveltejs/svelte",
  "repoUrl": "https://github.com/sveltejs/svelte",
  "repositoryDescription": "web development for the rest of us",
  "language": "JavaScript",
  "stars": 87592,
  "forks": 4960,
  "starsGained": 29,
  "builtBy": [
    {
      "username": "Rich-Harris",
      "profileUrl": "https://github.com/Rich-Harris",
      "avatarUrl": "https://avatars.githubusercontent.com/u/1162160?s=40&v=4"
    }
  ],
  "since": "daily",
  "trendingLanguage": "javascript",
  "trendingUrl": "https://github.com/trending/javascript?since=daily",
  "scrapedAt": "2026-06-30T08:00:00.000Z"
}
```

### Tips for best results

- Start with one or two languages and `maxItems` around 20.
- Schedule daily runs if you want a trend history.
- Use weekly or monthly windows for less noisy research.
- Enable README enrichment only for smaller runs or when text analysis is required.
- Store each scheduled run's dataset if you want time-series comparisons.

### Common workflows

- **Daily developer-news monitoring:** run the Actor every morning for `javascript`, `python`, and `typescript`, then send new repositories to a Slack channel or newsletter draft.
- **VC and startup discovery:** run weekly Trending snapshots for AI, data, security, and infrastructure languages to review fast-growing repositories.
- **Competitive intelligence:** monitor languages and frameworks related to your product category, then export `starsGained`, descriptions, and README text for classification.
- **Recruiting research:** review `builtBy` users and active repositories in specific technology communities as a starting point for public GitHub profile research.

### Integrations

You can connect the dataset to:

- Google Sheets for editorial calendars
- Slack alerts through Apify integrations
- Airtable or Notion for research queues
- BigQuery, Snowflake, or S3 for long-term trend storage
- Zapier or Make for no-code workflows
- Custom dashboards through the Apify API

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/github-trending-scraper').call({
  languages: ['javascript', 'python'],
  since: 'daily',
  maxItems: 20,
  includeReadme: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('fetch_cat/github-trending-scraper').call(run_input={
    'languages': ['javascript', 'python'],
    'since': 'daily',
    'maxItems': 20,
    'includeReadme': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~github-trending-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "languages": ["javascript", "python"],
    "since": "daily",
    "maxItems": 20,
    "includeReadme": false
  }'
```

### MCP and AI agents

You can use this actor from AI tools through the official Apify MCP server.

MCP endpoint:

```text
https://mcp.apify.com?tools=fetch_cat/github-trending-scraper
```

Claude Code setup:

```bash
claude mcp add apify-github-trending --url "https://mcp.apify.com?tools=fetch_cat/github-trending-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-github-trending": {
      "url": "https://mcp.apify.com?tools=fetch_cat/github-trending-scraper"
    }
  }
}
```

The default Apify MCP server can search and run Actors. The focused URL exposes only this Actor to clients that support tool-scoped MCP connections.

Example prompts for MCP usage:

Developer tooling trend summary:

```text
Use fetch_cat/github-trending-scraper to get today's top JavaScript and Python GitHub Trending repositories. Summarize the top 10 by stars gained and identify projects that look relevant to AI developer tooling.
```

Backend infrastructure review:

```text
Run the GitHub Trending Scraper for rust and go weekly trends, then create a table with repository, description, stars gained, and why each project may matter to backend infrastructure teams.
```

Weekly newsletter draft:

```text
Every Monday, run fetch_cat/github-trending-scraper for go, rust, and python weekly trends, then draft a short engineering newsletter with repository links and stars gained.
```

### Scheduling

For monitoring, schedule the actor to run daily or weekly. Keep the same input each time, then compare datasets across runs.

Good schedules include:

- Daily at 08:00 for newsletters
- Weekly on Monday for market research
- Monthly for broad ecosystem reports

### Limitations

- The actor extracts data visible on public GitHub Trending pages.
- GitHub may change page layout, which can require parser updates.
- Trending pages usually contain a limited number of repositories per language/window.
- README enrichment may not find every repository README because branch names and file names vary.
- The actor does not access private repositories or account-only data.

### FAQ

#### Why did I get fewer items than requested?

GitHub Trending pages have a finite number of visible repositories. If the source page has fewer repositories than your `maxItems`, the actor saves all available repositories.

#### Why is README text missing?

README enrichment checks common public README locations. Some repositories use different default branches, different file names, generated documentation, or no README.

#### Should I enable proxy?

Usually no. GitHub Trending is public. Enable proxy only if your run environment requires it or you repeatedly see network-level errors.

### Data freshness

GitHub Trending changes over time. The actor saves the state visible during the run and includes `scrapedAt` so you can compare snapshots.

### Legality

This actor collects public information from GitHub Trending pages. Use the data responsibly, respect GitHub's terms, avoid excessive scheduling, and do not use the output for spam, harassment, or invasive profiling.

### Related actors

- [GitHub Repositories Search Scraper](https://apify.com/fetch_cat/github-repositories-search-scraper) - search GitHub repositories by keyword, language, stars, and update date.
- [Hacker News Search Scraper](https://apify.com/fetch_cat/hacker-news-search-scraper) - monitor developer and startup discussions.
- [Stack Exchange Questions Scraper](https://apify.com/fetch_cat/stack-exchange-questions-scraper) - export technical question datasets.
- [Product Hunt Scraper](https://apify.com/fetch_cat/product-hunt-scraper) - track startup launches and product discovery.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses the inputs you provide and the public records needed to produce the documented dataset to produce the output dataset and sends requests to public Github Trending pages/endpoints; results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

# Actor input Schema

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

GitHub language slugs or names to scrape, for example `javascript`, `python`, or `TypeScript`. Leave empty to scrape the overall Trending page.

## `resumePendingLanguages` (type: `array`):

Optional language list copied from the previous run's PENDING\_SCOPES record. When supplied, it replaces Languages for this run so a cutoff can be resumed safely.

## `since` (type: `string`):

GitHub Trending time window to scrape.

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

Maximum number of repositories to save across all requested Trending pages.

## `includeReadme` (type: `boolean`):

Fetch up to 25 public README files from common main/master paths. This adds extra requests and is best for smaller runs; a missing README remains a row-level warning.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Leave disabled for normal GitHub Trending scraping.

## Actor input object example

```json
{
  "languages": [
    "javascript",
    "python"
  ],
  "since": "daily",
  "maxItems": 20,
  "includeReadme": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "languages": [
        "javascript",
        "python"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = { "languages": [
        "javascript",
        "python",
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/8bGq5K6a619Zk6u3b/builds/gv66Vcr5NLdpM0qQ8/openapi.json