# GitHub Trending Scraper (`automation-lab/github-trending-scraper`) Actor
Scrape GitHub Trending repositories by language and time range: today, this week, or this month. Extracts repo names, star counts, forks, star gains, and top contributors. Great for dev trend tracking, tech newsletters, and investment research. Export to JSON, CSV, or Excel.
- **URL**: https://apify.com/automation-lab/github-trending-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, News
- **Stats:** 62 total users, 32 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
Pay per event
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 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 Scraper
Scrape trending repositories from [GitHub Trending](https://github.com/trending). Get stars, forks, language, description, topics, license, last-updated date, star growth metrics, and full README content for the hottest open-source projects — with built-in AI/ML filtering.
### What does GitHub Trending Scraper do?
GitHub Trending Scraper extracts data from GitHub's trending repositories page and enriches each result with GitHub API data. Beyond the basic trending page data (stars, forks, language, description), it fetches topics, license, last-updated date, and optionally the full README markdown for each repository.
Key capabilities:
- 🔥 **Scrape trending repos** by language, time range (daily/weekly/monthly), and spoken language
- 🤖 **Filter for AI/ML repos only** — built-in classifier covering LLMs, deep learning, NLP, computer vision, and more
- 🏷️ **Filter by GitHub topics** — e.g., only repos tagged `llm`, `transformers`, `pytorch`
- 📄 **Extract full README content** — ideal for training datasets and documentation corpora
- 📈 **Star growth metrics** — calculate percentage growth (stars gained vs. prior baseline)
- 🔐 **License detection** — MIT, Apache-2.0, GPL, and others
### Who is it for?
- 🤖 **AI/ML researchers** — building curated datasets of trending ML repos with README content for training data, benchmarks, or competitive analysis
- 📊 **Technology analysts** — tracking programming language and framework popularity trends with rich metadata
- 🧑💻 **Software developers** — discovering trending repositories and emerging open-source tools in their stack
- 📝 **Developer advocates and newsletter writers** — curating weekly trending repos with descriptions and topics
- 🏢 **Engineering managers and CTOs** — scouting promising open-source projects for team adoption
- 💹 **Venture capitalists and investors** — identifying hot open-source projects gaining traction
### Why scrape GitHub Trending?
GitHub Trending is the go-to source for discovering popular and rising open-source projects, updated continuously to reflect what the developer community is actively starring.
Key reasons to scrape it:
- **AI/ML landscape monitoring** — instantly identify trending LLMs, fine-tuning tools, agentic frameworks, and AI infrastructure
- **Training data collection** — pair README content (docs, code examples, problem statements) with structured metadata for language model training
- **Developer tools discovery** — find new libraries and frameworks gaining traction before mainstream adoption
- **Competitive intelligence** — track trending projects in your tech stack over time
- **Investment research** — spot emerging technologies with accelerating star growth
- **Newsletter content curation** — automate weekly trending repo digests with rich metadata
### Data extracted
| Field | Type | Description |
|-------|------|-------------|
| `rank` | number | Position on the trending page |
| `owner` | string | Repository owner/organization |
| `name` | string | Repository name |
| `fullName` | string | Full name (`owner/name`) |
| `url` | string | Repository URL |
| `description` | string | Repository description |
| `language` | string | Primary programming language |
| `stars` | number | Total star count |
| `forks` | number | Total fork count |
| `starsToday` | number | Stars gained in the selected period |
| `starsGrowthPercent` | number | Percentage growth (starsToday / prior stars × 100) |
| `topics` | array | GitHub topic tags (e.g., `["llm", "transformers", "pytorch"]`) |
| `license` | string | SPDX license identifier (e.g., `MIT`, `Apache-2.0`) |
| `lastUpdated` | string | ISO timestamp of last push |
| `readmeContent` | string | Full README markdown (when `includeReadme: true`) |
| `builtBy` | array | Top contributors (username + avatar URL) |
| `scrapedAt` | string | ISO timestamp of extraction |
### How to scrape GitHub Trending
1. Go to [GitHub Trending Scraper](https://apify.com/automation-lab/github-trending-scraper) on Apify Store
2. Optionally select a programming language filter (e.g., `python`)
3. Choose a time range (today, this week, or this month)
4. Enable **AI/ML repos only** to filter for machine learning and AI repositories
5. Enable **Include README** to extract full documentation for training data use cases
6. Click **Start** and wait for results
7. Download data as JSON, CSV, or Excel
### Input parameters
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | string | `""` | Programming language filter (e.g., `"python"`, `"javascript"`) |
| `since` | string | `"daily"` | Time range: `daily`, `weekly`, or `monthly` |
| `spokenLanguageCode` | string | `""` | Spoken language code (e.g., `"en"`, `"zh"`) |
| `aiOnly` | boolean | `false` | Filter to AI/ML repos only |
| `filterTopics` | array | `[]` | Only return repos with at least one of these topic tags |
| `includeReadme` | boolean | `false` | Fetch full README markdown for each repo |
| `maxRepos` | integer | `0` | Max repos to return (0 = all, typically 25) |
#### Input example — AI/ML repos with READMEs
```json
{
"language": "python",
"since": "weekly",
"aiOnly": true,
"includeReadme": true,
"maxRepos": 10
}
````
#### Input example — LLM repos this month
```json
{
"since": "monthly",
"filterTopics": ["llm", "large-language-model", "transformers"],
"includeReadme": false
}
```
#### Input example — Standard trending (all repos)
```json
{
"language": "python",
"since": "daily"
}
```
### Output example
```json
{
"rank": 1,
"owner": "Blaizzy",
"name": "mlx-vlm",
"fullName": "Blaizzy/mlx-vlm",
"url": "https://github.com/Blaizzy/mlx-vlm",
"description": "MLX-VLM is a package for inference and fine-tuning of Vision Language Models (VLMs) on your Mac using MLX.",
"language": "Python",
"stars": 3747,
"forks": 410,
"starsToday": 343,
"starsGrowthPercent": 10.1,
"topics": ["apple-silicon", "llm", "local-ai", "mlx", "vision-language-model", "vision-transformer"],
"license": "MIT",
"lastUpdated": "2026-04-04T15:18:28Z",
"readmeContent": "# MLX-VLM\n\nMLX-VLM is a package for inference and fine-tuning...",
"builtBy": [
{ "username": "Blaizzy", "avatar": "https://avatars.githubusercontent.com/u/23445657" }
],
"scrapedAt": "2026-04-05T10:14:50.255Z"
}
```
### AI/ML filtering explained
When `aiOnly: true` is set, the scraper classifies each repo using a two-stage check:
1. **GitHub topic tags** — matches against 70+ AI/ML topics including: `machine-learning`, `deep-learning`, `llm`, `large-language-model`, `transformers`, `nlp`, `computer-vision`, `reinforcement-learning`, `generative-ai`, `pytorch`, `tensorflow`, `huggingface`, `langchain`, `rag`, `ai-agents`, `fine-tuning`, `embeddings`, `quantization`, `lora`, and more.
2. **Description keywords** — if topics don't match, scans the description for phrases like "machine learning", "large language model", "neural network", "computer vision", "fine-tuning", "vector store", etc.
For precise control, use `filterTopics` instead — it only matches repos whose topics include at least one of the specified tags.
### How much does it cost to scrape GitHub Trending?
GitHub Trending Scraper uses pay-per-event pricing with volume discounts:
| Event | Free tier | Standard | Power users |
|-------|-----------|----------|-------------|
| Run started | $0.001 | $0.001 | $0.001 |
| Repo extracted | $0.00115/repo | $0.001/repo | from $0.00028/repo |
Prices scale with your [Apify subscription tier](https://apify.com/pricing). The run-start fee is a one-time charge per run.
#### Cost examples
| Scenario | Repos | Approx. cost |
|----------|-------|--------------|
| Daily trending (all languages) | ~25 | ~$0.030 |
| Weekly Python AI/ML only | ~5–10 | ~$0.007–$0.013 |
| Monthly LLM repos | ~5–15 | ~$0.007–$0.018 |
Platform compute costs are negligible — typically under $0.001 per run. The **free Apify plan** includes enough compute to run daily trending scrapes at no cost.
### Tips
- 🔄 **Run on a schedule** to build a historical dataset of trending repos over time
- 🤖 **Use `aiOnly: true` + `since: "weekly"`** for a reliable weekly AI/ML digest
- 📈 **Sort by `starsGrowthPercent`** to identify repos with explosive recent momentum
- 🏷️ **Combine `filterTopics`** for targeted research (e.g., only `rag` + `langchain`)
- 📚 **Enable `includeReadme`** to collect paired (metadata + documentation) training data
- 🌐 **Use `spokenLanguageCode: "en"`** to exclude non-English repos from results
- 🔑 **Set `GITHUB_TOKEN`** environment variable to increase GitHub API rate limits (60 → 5000 req/hr)
### Integrations
GitHub Trending Scraper works with all Apify integrations:
- **Scheduled runs** — Track trending repos daily, weekly, or monthly. Schedule AI/ML monitoring for your research workflow.
- **Webhooks** — Get notified when a scrape finishes and pipe results to a data pipeline
- **Google Sheets** — Export trending repos directly to a spreadsheet for team visibility
- **Slack** — Send a daily AI/ML trending digest to your team channel
- **Make / Zapier** — Trigger downstream workflows when new trending AI repos appear
- **API** — Trigger runs programmatically and stream results into vector databases or training pipelines
Connect to [Zapier](https://apify.com/integrations/zapier), [Make](https://apify.com/integrations/make), or [Google Sheets](https://apify.com/integrations/google-sheets) for automated workflows.
### Using GitHub Trending Scraper with the Apify API
#### Node.js
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/github-trending-scraper').call({
language: 'python',
since: 'weekly',
aiOnly: true,
includeReadme: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} AI/ML trending repos`);
items.forEach(repo => {
console.log(`#${repo.rank} ${repo.fullName} ⭐ ${repo.stars} (+${repo.starsToday} / ${repo.starsGrowthPercent}%)`);
console.log(` Topics: ${repo.topics.join(', ')}`);
console.log(` README: ${repo.readmeContent.length} chars`);
});
```
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('automation-lab/github-trending-scraper').call(run_input={
'language': 'python',
'since': 'weekly',
'aiOnly': True,
'includeReadme': True,
})
dataset = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Found {len(dataset)} AI/ML trending repos')
for repo in dataset:
print(f"#{repo['rank']} {repo['fullName']} ⭐ {repo['stars']} (+{repo['starsToday']})")
print(f" Topics: {', '.join(repo['topics'])}")
print(f" License: {repo['license']}")
print(f" README: {len(repo['readmeContent'])} chars")
```
#### cURL
```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~github-trending-scraper/runs?token=YOUR_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"language": "python",
"since": "weekly",
"aiOnly": true,
"includeReadme": false
}'
```
### Use with Claude AI (MCP)
This actor is available as a tool in Claude AI through the Model Context Protocol (MCP). Add it to Claude Desktop, Cursor, Windsurf, or any MCP-compatible client.
#### Setup for Claude Code
```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/github-trending-scraper"
```
#### Setup for Claude Desktop, Cursor, or VS Code
Add this to your MCP config file:
```json
{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com?tools=automation-lab/github-trending-scraper"
}
}
}
```
#### Example prompts
- "What are the most starred AI/ML repositories trending on GitHub this week?"
- "Show me today's trending Python repositories tagged with LLM or transformers"
- "Find trending machine learning repos from the past month and extract their README docs"
- "Which GitHub repositories have the highest star growth percentage today?"
- "Get all trending repos with topics matching 'rag' or 'langchain' this week"
Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).
### Legality
Scraping publicly available data is generally legal according to the [US Court of Appeals ruling](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn) (HiQ Labs v. LinkedIn). This actor only accesses publicly available information from GitHub's trending page and public repository data via the GitHub API. It does not require authentication (though a GitHub token improves rate limits). Always review and comply with GitHub's Terms of Service before scraping. For personal data, ensure compliance with GDPR, CCPA, and other applicable privacy regulations.
### FAQ
**How many repos does it return?**
GitHub Trending typically shows 25 repositories per page. The exact number varies by time of day, language filter, and availability. With `aiOnly: true` or `filterTopics`, you may get fewer results since filtering happens after enrichment.
**How does the AI/ML filter work?**
The `aiOnly` filter checks GitHub topic tags first (70+ AI/ML topics like `llm`, `deep-learning`, `pytorch`) and then scans the repository description for AI/ML keywords. For precise control, use `filterTopics` with specific topic names.
**Does README extraction use the GitHub API rate limit?**
Yes — with `includeReadme: true`, one additional GitHub API request is made per repository. Without a `GITHUB_TOKEN`, GitHub's unauthenticated rate limit is 60 requests/hour. Set the `GITHUB_TOKEN` environment variable in the actor's input to get 5000 requests/hour (enough for many daily runs).
**What is `starsGrowthPercent`?**
It represents the percentage of stars gained in the selected period relative to prior total stars. For example, a repo with 1000 total stars and 100 gained today has a 10% growth rate. `null` is returned when there's insufficient data.
**Can I get trending developers instead of repos?**
Currently this scraper focuses on repositories. GitHub also has a trending developers page that could be supported in a future version.
**How often does GitHub update trending?**
GitHub Trending is updated continuously throughout the day. Running the scraper at different times may yield different results.
**The scraper returns fewer than 25 repos.**
GitHub Trending page size varies. Some language/period combinations have fewer trending repos. Additionally, `aiOnly` and `filterTopics` filters reduce results to only matching repos. This is expected behavior.
**`starsToday` seems too high — is it accurate?**
The `starsToday` field reflects stars gained in the selected period (daily, weekly, or monthly), not just today. For weekly/monthly trending, these numbers represent the full period's star gains.
**Rate limit errors or missing topics/license data.**
If you run the actor frequently or with many repos, GitHub's unauthenticated API limit (60 req/hr) may be hit. Set a `GITHUB_TOKEN` environment variable (free to create at github.com/settings/tokens) to increase the limit to 5000 requests/hour.
### Pricing
This actor uses pay-per-event pricing. See the Pricing tab on Apify Store for current rates.
### API usage
You can run this actor programmatically using the [Apify API](https://docs.apify.com/api/v2) or the Apify client libraries for Node.js and Python. See the code examples above for usage details.
### MCP
This actor is compatible with Model Context Protocol (MCP). Use it with AI assistants via the Apify MCP server.
### Related
- [GitHub Scraper](https://apify.com/automation-lab/github-scraper) — Repositories, profiles, trending, and search results from GitHub
- [Hacker News Scraper](https://apify.com/automation-lab/hackernews-scraper) — Stories from Hacker News front page, newest, Ask HN, and more
- [Stack Overflow Scraper](https://apify.com/automation-lab/stackoverflow-scraper) — Questions, answers, and tags from Stack Overflow
# Actor input Schema
## `language` (type: `string`):
Filter by programming language (e.g., python, javascript, rust). Leave empty for all languages.
## `since` (type: `string`):
Trending period to scrape.
## `spokenLanguageCode` (type: `string`):
Filter by spoken language code (e.g., en, zh, es). Leave empty for all.
## `aiOnly` (type: `boolean`):
When enabled, only return repositories related to AI, machine learning, LLMs, deep learning, and related topics. Uses topic tags and description keywords to classify repos.
## `filterTopics` (type: `array`):
Only return repos that have at least one of these GitHub topic tags (e.g., llm, transformers, pytorch). Leave empty to skip topic filtering.
## `includeReadme` (type: `boolean`):
When enabled, fetches the full README markdown for each repository and includes it in output. Useful for building training datasets or documentation corpora. Note: adds one API request per repo.
## `maxRepos` (type: `integer`):
Maximum number of repositories to return (0 = no limit, returns all trending repos, typically 25).
## Actor input object example
```json
{
"language": "python",
"since": "daily",
"aiOnly": false,
"filterTopics": [],
"includeReadme": false,
"maxRepos": 0
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"language": "python",
"since": "daily",
"spokenLanguageCode": "",
"aiOnly": false,
"filterTopics": [],
"includeReadme": false,
"maxRepos": 0
};
// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"language": "python",
"since": "daily",
"spokenLanguageCode": "",
"aiOnly": False,
"filterTopics": [],
"includeReadme": False,
"maxRepos": 0,
}
# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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",
"since": "daily",
"spokenLanguageCode": "",
"aiOnly": false,
"filterTopics": [],
"includeReadme": false,
"maxRepos": 0
}' |
apify call automation-lab/github-trending-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=automation-lab/github-trending-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "GitHub Trending Scraper",
"description": "Scrape GitHub Trending repositories by language and time range: today, this week, or this month. Extracts repo names, star counts, forks, star gains, and top contributors. Great for dev trend tracking, tech newsletters, and investment research. Export to JSON, CSV, or Excel.",
"version": "0.1",
"x-build-id": "1QzNqOpJnJlv1geEM"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/automation-lab~github-trending-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~github-trending-scraper/runs": {
"post": {
"operationId": "runs-sync-automation-lab-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/automation-lab~github-trending-scraper/run-sync": {
"post": {
"operationId": "run-sync-automation-lab-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": "Programming language",
"type": "string",
"description": "Filter by programming language (e.g., python, javascript, rust). Leave empty for all languages."
},
"since": {
"title": "Time range",
"enum": [
"daily",
"weekly",
"monthly"
],
"type": "string",
"description": "Trending period to scrape.",
"default": "daily"
},
"spokenLanguageCode": {
"title": "Spoken language",
"type": "string",
"description": "Filter by spoken language code (e.g., en, zh, es). Leave empty for all."
},
"aiOnly": {
"title": "AI/ML repos only",
"type": "boolean",
"description": "When enabled, only return repositories related to AI, machine learning, LLMs, deep learning, and related topics. Uses topic tags and description keywords to classify repos.",
"default": false
},
"filterTopics": {
"title": "Filter by topics",
"type": "array",
"description": "Only return repos that have at least one of these GitHub topic tags (e.g., llm, transformers, pytorch). Leave empty to skip topic filtering.",
"items": {
"type": "string"
}
},
"includeReadme": {
"title": "Include README content",
"type": "boolean",
"description": "When enabled, fetches the full README markdown for each repository and includes it in output. Useful for building training datasets or documentation corpora. Note: adds one API request per repo.",
"default": false
},
"maxRepos": {
"title": "Max repositories",
"minimum": 0,
"maximum": 25,
"type": "integer",
"description": "Maximum number of repositories to return (0 = no limit, returns all trending repos, typically 25).",
"default": 0
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```