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

Pull GitHub trending repositories with stars, forks, language, description, contributors, license, topics, and full repo metadata. Choose daily, weekly, or monthly windows and filter by programming language or spoken language. Export to JSON, CSV, or Excel for developer intelligence and tech trends.

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

## Pricing

from $8.25 / 1,000 items

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🐙 GitHub Trending Repos Scraper

> 🚀 **Pull GitHub's daily, weekly, and monthly trending repositories with full repo metadata.** Multi-period and multi-language fanout reaches 100+ unique repos per run. No GitHub token required.

> 🕒 **Last updated:** 2026-05-01 · **📊 24 fields** per repo · **🐙 220M+ public repos on GitHub** · **📈 multi-period fanout** · **🔗 GitHub API enrichment**

The **GitHub Trending Repos Scraper** extracts trending repositories from the public GitHub trending page and enriches each with full repo metadata via the GitHub API: stars, forks, language, topics, license, watchers, open issues, default branch, repo size, archived flag, fork flag, template flag, and full ISO timestamps for created, updated, and pushed dates.

GitHub trending is the canonical signal for what developers are building right now. VC firms screen for emerging projects, dev relations teams track adoption, and tech writers cover what is rising. The official trending page caps at 25 entries per query, so this Actor combines daily, weekly, and monthly windows across the top 14 programming languages to reach 100+ unique repos per run.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| VC analysts, developer relations, tech writers, recruiters, dev tool teams | Emerging project discovery, language trend tracking, competitive intel, content research |

---

### 📋 What the GitHub Trending Repos Scraper does

Five filtering workflows in a single run:

- 📈 **Multi-period fanout.** Combines daily, weekly, and monthly trending lists when `since` is set to the default.
- 🌐 **Multi-language fanout.** Walks the top 14 programming languages (TypeScript, Python, Rust, Go, Java, C++, etc.) when no language is specified.
- 🗣️ **Spoken-language filter.** Optional `spoken_language_code` filter for repos with READMEs in a specific language.
- 🔍 **Language filter.** Restrict results to a single programming language (e.g. only `rust`).
- 🔗 **API enrichment.** Each parsed repo is enriched via `api.github.com/repos/{owner}/{name}` for full metadata.

Each row reports rank, full name, owner, name, URL, description, language, language color, star and fork totals, stars gained in the period, period label, contributors shown on the trending card, plus enriched fields: GitHub repo ID, homepage, license, default branch, open issues, watchers, repo size in KB, archived, fork, is-template, topics, and timestamps for created, updated, and pushed.

> 💡 **Why it matters:** GitHub trending is one of the few free signals that reflects developer attention in real time. VCs use it for early scouting. DevRel teams use it to gauge competitor traction. Tech writers use it to find stories. The 25-row cap on the official page is a hard ceiling, so multi-period and multi-language fanout is the practical way to reach 100+ unique repos.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Repos to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>language</code></td><td>string</td><td>empty</td><td>Programming language filter (e.g. <code>rust</code>, <code>python</code>). Empty triggers fanout across top 14 languages.</td></tr>
<tr><td><code>spokenLanguage</code></td><td>string</td><td>empty</td><td>Spoken language code (e.g. <code>en</code>, <code>zh</code>). Filters repos by README language.</td></tr>
<tr><td><code>since</code></td><td>string</td><td><code>"daily"</code></td><td><code>daily</code>, <code>weekly</code>, or <code>monthly</code>. Daily triggers period fanout.</td></tr>
<tr><td><code>enrichWithApi</code></td><td>boolean</td><td><code>true</code></td><td>Adds full GitHub API enrichment per repo (license, topics, issues, etc.).</td></tr>
</tbody>
</table>

**Example: top 100 trending repos this week, all languages.**

```json
{
    "maxItems": 100,
    "since": "weekly",
    "enrichWithApi": true
}
````

**Example: trending Rust repos with full enrichment.**

```json
{
    "maxItems": 50,
    "language": "rust",
    "since": "monthly",
    "enrichWithApi": true
}
```

> ⚠️ **Good to Know:** GitHub's anonymous API rate limit is 60 requests per hour per IP. With `enrichWithApi=true` on a 100-repo run, you stay well under that. For very large runs, disable enrichment or rotate proxies.

***

### 📊 Output

Each repo record contains **24 fields** when enrichment is enabled, **13 fields** without. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🏆 `rank` | integer | `1` |
| 🏷️ `fullName` | string | `"warpdotdev/warp"` |
| 👤 `owner` | string | `"warpdotdev"` |
| 📦 `name` | string | `"warp"` |
| 🔗 `url` | string | `"https://github.com/warpdotdev/warp"` |
| 📝 `description` | string | null | `"Warp is an agentic development environment..."` |
| 🧮 `language` | string | null | `"Rust"` |
| 🎨 `languageColor` | string | null | `"#dea584"` |
| ⭐ `totalStars` | integer | `49284` |
| 🍴 `totalForks` | integer | `3208` |
| 📈 `starsThisPeriod` | integer | `8399` |
| 📅 `period` | string | `"daily"` |
| 👥 `contributorsShown` | array | `[]` |
| 🆔 `githubId` | integer | `384219990` |
| 🏠 `homepage` | string | null | `"https://warp.dev"` |
| 📄 `license` | string | null | `"AGPL-3.0"` |
| 🌿 `defaultBranch` | string | `"master"` |
| 🐛 `openIssues` | integer | `3265` |
| 👁️ `watchers` | integer | `312` |
| 💾 `size` | integer | `154580` |
| 🗄️ `archived` | boolean | `false` |
| 🍴 `fork` | boolean | `false` |
| 📋 `isTemplate` | boolean | `false` |
| 🏷️ `topics` | array | `["rust", "terminal", "shell"]` |
| 📅 `createdAt` | ISO 8601 | `"2021-07-08T18:48:08Z"` |
| 📅 `updatedAt` | ISO 8601 | `"2026-04-30T22:13:28Z"` |
| 📅 `pushedAt` | ISO 8601 | `"2026-04-30T22:13:30Z"` |

#### 📦 Sample records

<details>
<summary><strong>🚀 Top trending Rust repo: warpdotdev/warp</strong></summary>

```json
{
    "rank": 1,
    "fullName": "warpdotdev/warp",
    "owner": "warpdotdev",
    "name": "warp",
    "url": "https://github.com/warpdotdev/warp",
    "description": "Warp is an agentic development environment, born out of the terminal.",
    "language": "Rust",
    "languageColor": "#dea584",
    "totalStars": 49284,
    "totalForks": 3208,
    "starsThisPeriod": 8399,
    "period": "daily",
    "license": "AGPL-3.0",
    "openIssues": 3265,
    "watchers": 312,
    "topics": ["bash", "linux", "macos", "rust", "shell", "terminal", "wasm", "zsh"],
    "createdAt": "2021-07-08T18:48:08Z"
}
```

</details>

<details>
<summary><strong>📈 Mid-rank Python repo with topics</strong></summary>

```json
{
    "rank": 7,
    "fullName": "openai-engineering/example-tooling",
    "owner": "openai-engineering",
    "name": "example-tooling",
    "url": "https://github.com/openai-engineering/example-tooling",
    "language": "Python",
    "totalStars": 12450,
    "starsThisPeriod": 1830,
    "period": "weekly",
    "license": "MIT",
    "topics": ["ai", "agents", "llm", "tooling"],
    "openIssues": 84,
    "watchers": 220
}
```

</details>

<details>
<summary><strong>🍴 Fork without enrichment fields</strong></summary>

```json
{
    "rank": 14,
    "fullName": "researcher123/trending-fork",
    "owner": "researcher123",
    "name": "trending-fork",
    "url": "https://github.com/researcher123/trending-fork",
    "language": "JavaScript",
    "totalStars": 410,
    "starsThisPeriod": 78,
    "period": "monthly",
    "fork": true,
    "topics": []
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🆓 | **No GitHub token.** Reads the public trending page plus anonymous API access. |
| 📈 | **Period fanout.** Combines daily, weekly, and monthly to break the 25-row ceiling. |
| 🌐 | **Language fanout.** Walks the top 14 programming languages for breadth. |
| 🔗 | **API enrichment.** Adds license, topics, issues, watchers, and timestamps per repo. |
| 🆔 | **Stable repo IDs.** Each row carries the GitHub repo ID for cross-referencing. |
| 🚀 | **Fast.** Typical 100-row pull completes in 25 to 35 seconds. |
| 🛠️ | **Configurable.** Disable enrichment for faster, lighter pulls when you only need names and stars. |

> 📊 In a single 29-second run the Actor returned 100 unique trending repos across 3 periods and 14 languages.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| Direct trending page scrape | Free | 25 rows max | Live | Single period | Engineer hours |
| GitHub Search API | Free with token | Star-sorted | Live | Star range only | Token required |
| Paid dev intel platforms | $$$ subscription | Aggregated | Daily | Built-in | Account setup |
| **⭐ GitHub Trending Repos Scraper** *(this Actor)* | Pay-per-event | 100+ via fanout | Live | Period, language | None |

Same trending page GitHub publishes, with multi-period and multi-language fanout to reach more rows.

***

### 🚀 How to use

1. 🆓 **Create a free Apify account.** [Sign up here](https://console.apify.com/sign-up?fpr=vmoqkp) and get $5 in free credit.
2. 🔍 **Open the Actor.** Search for "GitHub Trending" in the Apify Store.
3. ⚙️ **Pick filters.** Optional language and spoken-language filters.
4. ▶️ **Click Start.** A 100-row run typically finishes in 25 to 35 seconds.
5. 📥 **Download.** Export as CSV, Excel, JSON, or XML.

> ⏱️ Total time from sign-up to first dataset: under five minutes.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 💰 VC & scouting

- Surface early-stage projects before mainstream coverage
- Track velocity of stars-per-day for emerging repos
- Identify under-the-radar founders by repo activity
- Build alert feeds on specific languages or topics

</td>
<td width="50%">

#### 📰 Tech writing & content

- Find story angles in real developer momentum
- Reference specific repos with stable URLs and stats
- Track which tools rise into trending
- Build weekly trend digests programmatically

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Developer relations

- Monitor competitor and adjacent projects
- Track adoption of your own dependencies
- Identify rising contributors to engage with
- Benchmark your repo's trending position

</td>
<td width="50%">

#### 👥 Recruiting

- Spot active maintainers in your stack
- Source candidates by language and recency
- Identify trending project teams hiring soon
- Build talent feeds tied to GitHub activity

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating GitHub Trending Repos Scraper

Run this Actor on a schedule, from your codebase, or inside another tool:

- **Node.js** SDK: see [Apify JavaScript client](https://docs.apify.com/api/client/js/) for programmatic runs.
- **Python** SDK: see [Apify Python client](https://docs.apify.com/api/client/python/) for the same flow in Python.
- **HTTP API**: see [Apify API docs](https://docs.apify.com/api/v2) for raw REST integration.

Schedule daily or weekly runs from the Apify Console. Pipe results into Google Sheets, S3, BigQuery, or your own webhook with the built-in [integrations](https://docs.apify.com/platform/integrations).

***

### ❓ Frequently Asked Questions

<details>
<summary><strong>📈 What does period fanout do?</strong></summary>

When `since` is set to `daily`, the Actor combines daily, weekly, and monthly trending lists to break past the 25-row cap on a single page. Set `since` explicitly to skip fanout.

</details>

<details>
<summary><strong>🌐 What does language fanout do?</strong></summary>

When no `language` is specified, the Actor walks the top 14 programming languages to broaden coverage. Each language has its own trending list of up to 25 rows.

</details>

<details>
<summary><strong>🔗 Why use API enrichment?</strong></summary>

The trending page returns rank, name, description, language, and star totals. The GitHub API adds license, topics, watchers, open issues, default branch, repo size, archived flag, and full timestamps.

</details>

<details>
<summary><strong>🛡️ What about GitHub API rate limits?</strong></summary>

Anonymous access is 60 requests per hour per IP. A 100-row enriched run uses 100 requests. For higher volumes, disable enrichment or rotate proxies.

</details>

<details>
<summary><strong>📦 How many repos can I pull?</strong></summary>

Up to roughly 350 unique repos per run via full fanout (14 languages × 3 periods × 25 rows minus overlaps). Free plan caps at 10, paid plan at 1,000,000.

</details>

<details>
<summary><strong>🗣️ What is the spoken-language filter?</strong></summary>

GitHub trending supports filtering by README language code (e.g. `en` for English, `zh` for Chinese). Pass any valid two-letter code.

</details>

<details>
<summary><strong>📅 How often does GitHub trending refresh?</strong></summary>

The trending page recomputes throughout the day. Each run hits the live page so you always get current results.

</details>

<details>
<summary><strong>💼 Can I use this for commercial work?</strong></summary>

Yes. The Actor reads only what GitHub publicly serves to any browser. Always honor GitHub's terms of service when republishing repo data.

</details>

<details>
<summary><strong>💳 Do I need a paid Apify plan?</strong></summary>

The free plan returns up to 10 rows per run. Paid plans return up to 1,000,000.

</details>

<details>
<summary><strong>⚠️ What if a run fails?</strong></summary>

Most failures are transient. Retry once. If the issue persists, [open a contact form](https://tally.so/r/BzdKgA) and include the run URL.

</details>

<details>
<summary><strong>🔁 How fresh is the data?</strong></summary>

Live. Each run hits GitHub trending and the GitHub API at run time.

</details>

<details>
<summary><strong>⚖️ Is this legal?</strong></summary>

Yes. The Actor reads public HTML and the public GitHub API. It does not authenticate, does not bypass rate limits, and does not scrape private repos.

</details>

***

### 🔌 Integrate with any app

- [**Make**](https://apify.com/integrations/make) - drop run results into 1,800+ apps.
- [**Zapier**](https://apify.com/integrations/zapier) - trigger automations off completed runs.
- [**Slack**](https://apify.com/integrations/slack) - post run summaries to a channel.
- [**Google Sheets**](https://apify.com/integrations/google-sheets) - sync each run into a spreadsheet.
- [**Webhooks**](https://docs.apify.com/platform/integrations/webhooks) - notify your own services on run finish.
- [**Airbyte**](https://apify.com/integrations/airbyte) - load runs into Snowflake, BigQuery, or Postgres.

***

### 🔗 Recommended Actors

- [**💬 Stack Exchange Q\&A Scraper**](https://apify.com/parseforge/stack-exchange-qa-scraper) - pair trending repos with developer Q\&A.
- [**📚 Wikipedia Pageviews Scraper**](https://apify.com/parseforge/wikipedia-pageviews-scraper) - cross-reference repo trends with public-interest spikes.
- [**🅱️ Bing Search Scraper**](https://apify.com/parseforge/bing-search-scraper) - track which repos rank for which keywords.
- [**🦆 DuckDuckGo Search Scraper**](https://apify.com/parseforge/duckduckgo-search-scraper) - alternative SERP signal alongside GitHub data.
- [**📰 Substack Publication Scraper**](https://apify.com/parseforge/substack-publication-scraper) - capture how technical newsletters cover trending repos.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more pre-built scrapers and data tools.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) and we'll route the question to the right person.

***

> GitHub is a registered trademark of GitHub, Inc., a subsidiary of Microsoft. This Actor is not affiliated with or endorsed by GitHub. It uses only publicly accessible HTML and API endpoints.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

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

Filter by programming language. Examples: `python`, `typescript`, `rust`, `go`. Leave empty for all languages.

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

Filter by README spoken language code (e.g. `en`, `zh`, `ja`, `ko`). Leave empty for any.

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

Trending window: `daily`, `weekly`, or `monthly`.

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

When enabled, each trending repo is queried via api.github.com to add full stats: license, default branch, open issues, watchers, topics, push date, etc.

## Actor input object example

```json
{
  "maxItems": 25,
  "since": "daily",
  "enrichWithApi": true
}
```

# 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 = {
    "maxItems": 25,
    "since": "daily"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "maxItems": 25,
    "since": "daily",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Trending Repos Scraper",
        "description": "Pull GitHub trending repositories with stars, forks, language, description, contributors, license, topics, and full repo metadata. Choose daily, weekly, or monthly windows and filter by programming language or spoken language. Export to JSON, CSV, or Excel for developer intelligence and tech trends.",
        "version": "1.0",
        "x-build-id": "0Tf2YHeCvK6k4dchT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~github-trending-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~github-trending-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~github-trending-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "language": {
                        "title": "Programming language",
                        "type": "string",
                        "description": "Filter by programming language. Examples: `python`, `typescript`, `rust`, `go`. Leave empty for all languages."
                    },
                    "spokenLanguage": {
                        "title": "Spoken language",
                        "type": "string",
                        "description": "Filter by README spoken language code (e.g. `en`, `zh`, `ja`, `ko`). Leave empty for any."
                    },
                    "since": {
                        "title": "Time range",
                        "enum": [
                            "daily",
                            "weekly",
                            "monthly"
                        ],
                        "type": "string",
                        "description": "Trending window: `daily`, `weekly`, or `monthly`.",
                        "default": "daily"
                    },
                    "enrichWithApi": {
                        "title": "Enrich with GitHub API",
                        "type": "boolean",
                        "description": "When enabled, each trending repo is queried via api.github.com to add full stats: license, default branch, open issues, watchers, topics, push date, etc.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
