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

Scrape trending GitHub repositories by programming language and time range. Get repo names, stars, forks, descriptions, and daily/weekly/monthly star growth in structured JSON.

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

## Pricing

from $0.01 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Repositories Scraper

Scrape trending repositories from [GitHub Trending](https://github.com/trending) by programming language and time range. Get repo names, stars, forks, descriptions, primary languages, and period star counts — all in structured JSON output.

This Actor runs on the [Apify platform](https://apify.com), giving you scheduled runs, API access, and automatic data export to JSON, CSV, or Excel.

### What does GitHub Trending Repositories Scraper do?

This Actor extracts repository data from [GitHub Trending](https://github.com/trending) pages. Each result includes the repo name, full URL, description, primary programming language, total star count, fork count, and stars gained in the selected period (today, this week, or this month).

It supports all programming languages available on GitHub Trending — simply enter a language like `python` or `javascript` to filter results, or leave it empty for all languages.

### Why use GitHub Trending Repositories Scraper?

- **Track trending repos** — Monitor what's popular daily, weekly, or monthly across any programming language
- **Market research** — Identify rising projects and tools by language ecosystem
- **Developer intelligence** — Feed trending data into dashboards, newsletters, or recommendation engines
- **Automated curation** — Schedule daily runs and get alerts when new repos trend in your stack

### Use Cases

#### How to track trending Python repositories daily

Set `language: "python"` and `since: "daily"` to get the top trending Python repos each day. The `stars_today` field shows exactly how many stars were gained in the period.

#### How to find trending AI agent repositories

Use `language: "python"` with `since: "weekly"` to discover trending AI and LLM agent frameworks. Filter results by keywords like "agent", "LLM", or "transformer" in the description field.

#### How to monitor trending JavaScript frameworks

Set `language: "javascript"` and `since: "weekly"` to track which JS frameworks are gaining traction. The star count and fork count help gauge community adoption.

#### How to discover new Rust projects

Use `language: "rust"` with `since: "monthly"` for a broader view of the Rust ecosystem. Rust trending repos often include CLI tools, WebAssembly projects, and systems libraries.

### How to use GitHub Trending Repositories Scraper

1. Open the Actor in [Apify Console](https://console.apify.com)
2. (Optional) Enter a programming language like `python` or `javascript` to filter results
3. Select the time range: **Daily**, **Weekly**, or **Monthly**
4. Set how many repositories you want (max 100)
5. Click **Run** and wait for results

That's it. Your scraped data appears as a structured table in the **Output** tab and can be downloaded in JSON, HTML, CSV, or Excel.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `language` | string | — | Programming language filter (e.g. `python`, `javascript`). Leave empty for all languages. |
| `since` | string | `daily` | Time range: `daily`, `weekly`, or `monthly` |
| `max_results` | integer | 25 | Maximum number of repositories to return (1–100) |

Example input:

```json
{
    "language": "python",
    "since": "weekly",
    "max_results": 10
}
````

### Output

Each result is a repository object with the following fields:

```json
{
    "name": "psf/black",
    "url": "https://github.com/psf/black",
    "description": "The uncompromising Python code formatter",
    "language": "Python",
    "stars": 40123,
    "forks": 2567,
    "stars_today": 89,
    "stars_period_label": "stars today"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from Apify Console.

#### Data fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Full repository name (`owner/repo`) |
| `url` | string | Full GitHub URL |
| `description` | string | Repository description |
| `language` | string or null | Primary programming language |
| `stars` | integer | Total star count |
| `forks` | integer | Total fork count |
| `stars_today` | integer or null | Stars gained in the selected period |
| `stars_period_label` | string | Period label (e.g. "stars today", "stars this week") |

### Pricing

**Cost example:** 25 repos = 15 paid results × $0.02 = **$0.30 per run**. First 10 results are free.

The first 10 results per run are free. After that, each additional result costs $0.02. A typical daily run with 25 results costs $0.30.

### Tips

- **Filter by language** — Use the `language` field to narrow results to your stack. Empty = all languages.
- **Choose the right since** — `daily` works best for fresh trends. Use `weekly` or `monthly` for sustained momentum.
- **Limit results** — Set `max_results` to 25 or fewer to stay within the free tier.
- **Schedule daily** — For the best experience, schedule this Actor to run daily and track trending repos over time.

### FAQ, disclaimers, and support

**Is scraping GitHub trending allowed?** This Actor only extracts publicly available data from GitHub's trending page, which is accessible without authentication. Always review GitHub's Terms of Service for compliance.

**Known limitations:** The Actor parses the public GitHub trending HTML page, so results depend on GitHub's page structure. If GitHub significantly changes their markup, the scraper may need an update.

**Need help?** Open an issue on the [Issues tab](https://console.apify.com) or contact us for custom solutions.

# Actor input Schema

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

Programming language filter (e.g. 'python', 'javascript'). Leave empty for all languages.

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

Time range for trending repositories

## `max_results` (type: `integer`):

Maximum number of repositories to return

## Actor input object example

```json
{
  "language": "python",
  "since": "daily",
  "max_results": 25
}
```

# 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 = {
    "language": "python"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ef12/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 = { "language": "python" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Trending Repositories Scraper",
        "description": "Scrape trending GitHub repositories by programming language and time range. Get repo names, stars, forks, descriptions, and daily/weekly/monthly star growth in structured JSON.",
        "version": "0.0",
        "x-build-id": "VDgEE3yjDODLw9mTk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ef12~github-trending-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ef12-github-trending-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ef12~github-trending-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ef12-github-trending-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ef12~github-trending-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ef12-github-trending-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Programming language filter (e.g. 'python', 'javascript'). Leave empty for all languages."
                    },
                    "since": {
                        "title": "Time Range",
                        "enum": [
                            "daily",
                            "weekly",
                            "monthly"
                        ],
                        "type": "string",
                        "description": "Time range for trending repositories",
                        "default": "daily"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of repositories to return",
                        "default": 25
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
