# GitHub Trending Discovery - Daily Repositories & Changes (`maydit/github-trending-discovery-monitor`) Actor

Discover daily GitHub Trending repositories by language, with exact ranks, stars gained today, filters and saved rank changes. No token; source evidence and clean JSON.

- **URL**: https://apify.com/maydit/github-trending-discovery-monitor.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 saved observations

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## GitHub Trending Discovery

Find repositories appearing on GitHub's daily Trending lists. Choose a language, set a small result limit and get ranked observations with exact star counts, stars gained today, source links and collection timestamps.

Use it to build developer newsletters, discover emerging AI projects, refresh engineering research watchlists or feed a repository-review workflow. Optional saved comparisons show how a repository's rank and total stars changed between **your own successful observations**.

### Start in one minute

1. Keep **Languages** set to `python`, or use a GitHub language slug such as `typescript`, `rust` or `go`. Use `all` for the all-language list.
2. Set **Maximum results** to `5` for a small first run.
3. Run the Actor and open the **Repositories** table. Export JSON, CSV, Excel or a dataset URL from Apify.

No GitHub token, browser cookies or proxy configuration is required. The Actor reads public daily Trending pages and checks their robots policy. A source failure is reported in `SUMMARY`; failed pages do not produce substitute records.

```json
{
  "languages": ["python"],
  "maxResults": 5
}
```

### What one row means

One row is one repository observed on one language's daily Trending list at `observedAt`. The same repository on two selected lists produces two observations, because its rank and list context differ.

| Field | Meaning |
| --- | --- |
| `fullName` | Exact source owner/repository name |
| `rank` | Position in the complete fetched daily list, before your filters |
| `listLanguage` | Selected list slug, or `all` |
| `programmingLanguage` | Main language displayed on the repository card; `null` if absent |
| `stars` / `forks` | Exact integer counts displayed by GitHub; missing values stay `null` |
| `starsToday` | GitHub's displayed “stars today” count; not a calculation from stored history |
| `description` | Public repository description, when present |
| `url` / `sourceUrl` | Repository and exact Trending list URLs |
| `observedAt` | UTC time this response was parsed |
| `recordId` | Stable identity for a repository within a particular language list |
| `comparisonStatus` | `not_requested`, `new`, `changed` or `unchanged` |
| `rankChange` | Previous observed rank minus current rank; positive means a higher placement |
| `starsChange` | Current total stars minus the previous observation's total stars |
| `changedFields` / `previous` | Changed field names and the prior saved observation, when comparison is enabled |

`rankChange` is not an official GitHub historical metric. Lists change continuously; observations made hours apart are not a reconstruction of yesterday's final ranking. GitHub's “today” window is source-defined. Star counts can fall, so negative changes are preserved.

### Useful recipes

**A daily engineering discovery list**

```json
{
  "languages": ["typescript"],
  "maxResults": 10
}
```

**Find AI-related descriptions on a list**

```json
{
  "languages": ["python"],
  "keywords": ["agent", "inference", "model"],
  "minStarsToday": 20,
  "maxResults": 10
}
```

Keywords use literal, case-insensitive OR matching across repository names and descriptions. They are applied after fetching a current Trending page. An empty match is a valid outcome; this is not a GitHub-wide search.

**Emit only new or changed observations**

```json
{
  "languages": ["python"],
  "maxResults": 25,
  "comparePrevious": true,
  "onlyChanges": true,
  "snapshotName": "python-discovery"
}
```

The first comparison run establishes a baseline and emits matching observations as `new`. Later runs can produce zero rows when nothing has changed. `SUMMARY` separates that result from failed source requests.

### Input controls

| Input | Default | Limits and behavior |
| --- | --- | --- |
| `languages` | `['python']` when empty or omitted | Up to 3 GitHub language slugs; case-insensitive deduplication; `all` selects the overview |
| `keywords` | `[]` | Up to 10 literal phrases, at most 100 characters each |
| `minStarsToday` | `0` | Minimum displayed growth; positive values exclude missing counts |
| `maxResults` | `5` | 1–75 output rows across the run; languages are processed in input order |
| `comparePrevious` | `false` | Compare against a saved baseline in your account |
| `onlyChanges` | `false` | Enables comparison and suppresses unchanged rows |
| `snapshotName` | `default` | 1–80 letters, digits, underscores or hyphens |
| `maxRunSeconds` | `90` | 30–120 second application budget |

Choose actual GitHub language slugs. An unsupported or currently empty list can fail validation rather than returning invented repositories. There are no arbitrary URL inputs and no weekly or monthly query modes: the current robots policy restricts those date-window query URLs.

### Pricing and result limits

The configured result price is **$0.002 per saved repository observation**: 5 rows are $0.01 and 1,000 rows are $2 in result charges. The Actor's live Pricing tab is authoritative for any separate startup charge or platform fees.

Unchanged rows suppressed by `onlyChanges`, rejected pages and filtered-out repositories do not produce result events. Set Apify's maximum total charge as a second limit. The Actor checks the remaining charge allowance before output and stops at the platform's reported limit. A source outage may still incur applicable startup or platform charges.

### Saved comparison behavior

Comparison history lives in the named key-value store `github-trending-discovery-monitor-history` in the account running the Actor. The language list, filters and `snapshotName` define its scope. A different scope starts separate history. Run only one writer per scope at a time; use separate snapshot names for independent workflows.

Each source page is parsed and validated completely before emitting any of its observations. History advances only for dataset output acknowledged as saved. A limited or partial run can update those confirmed rows, while the summary reports its limits. Previously seen repositories missing from today's list are **not** labeled removed or deleted. This Actor does not compare repository content or commits.

If an output request fails after delivery but before acknowledgement, the remote dataset may contain the row even though this run cannot confirm it. The Actor stops instead of retrying an uncertain charge, and does not advance that row's history. Downstream consumers can deduplicate by `recordId`, `contentHash` and `observedAt`.

### Coverage, failures and responsible use

- These are current **daily Trending lists**, not every GitHub repository, every new project or an exhaustive popularity ranking.
- Trending presence, stars and rank changes do not establish adoption, revenue, quality or investment value.
- Source HTML and availability can change. HTTP errors, robot exclusions, challenges, malformed counts and unexpected page structures are surfaced; no cached or fabricated data is substituted.
- A transient HTTP 502/503/504 can receive one retry within the run budget. HTTP 429 stops remaining source work. No proxy or alternate access route is used to bypass a refusal.
- Output caps apply after filtering. If an earlier language fills the cap, later languages may not be reached. Read `sourceCoverage`, `sourcesNotReached`, `selectionTruncated`, `incomplete` and `status` in `SUMMARY` before treating a run as complete.
- The source's missing values remain `null`. Empty keyword matches can succeed with zero rows; unavailable or invalid source pages cannot.

### Automation and delivery

Save an Apify task for a repeatable input, then schedule it at a cadence appropriate for a daily source. Send successful datasets to your existing spreadsheet, database, n8n or Make workflow through Apify integrations. For AI workflows, pass the dataset rows together with `SUMMARY` so the consumer can distinguish limited coverage from a complete selected check.

Use the Actor's **API** tab for the exact endpoint and input schema. Public source links and timestamps remain attached to each observation for downstream verification.

### Need repository watchlists instead?

This Actor discovers projects from Trending lists. For a fixed repository watchlist, use our [GitHub Repository Change Monitor](https://apify.com/maydit/github-repository-change-monitor). Browse [Mayd It data tools](https://mayd-it.com/data-tools/) for related workflows and examples.

For an issue, use the Apify Issues tab and include the run URL, selected language and expected behavior. Do not include account tokens or private credentials.

# Actor input Schema

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

Up to three GitHub language slugs, such as python, typescript, rust or all. Empty uses python. Daily pages only; unknown languages fail clearly.

## `keywords` (type: `array`):

Optional literal, case-insensitive phrases; a repository matches any phrase in its name or description. No AI scoring.

## `minStarsToday` (type: `integer`):

Filter the exact daily count shown by GitHub. A positive threshold excludes rows whose source count is unavailable.

## `maxResults` (type: `integer`):

Total saved row cap across language lists. The same repository in two lists is two list observations. See SUMMARY for truncation.

## `comparePrevious` (type: `boolean`):

Establish history after confirmed output. Reuse the same language/filter scope and snapshot. Missing repositories are not removals.

## `onlyChanges` (type: `boolean`):

Enables comparison. An unchanged repeat can correctly save zero rows.

## `snapshotName` (type: `string`):

1–80 letters, numbers, underscores or hyphens. Reuse for the same watchlist; choose a new name for independent history.

## `maxRunSeconds` (type: `integer`):

Shared deadline for all source requests. Stops safely within this budget or the platform timeout, whichever is earlier.

## Actor input object example

```json
{
  "languages": [
    "python"
  ],
  "keywords": [],
  "minStarsToday": 0,
  "maxResults": 5,
  "comparePrevious": false,
  "onlyChanges": false,
  "snapshotName": "default",
  "maxRunSeconds": 90
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `report` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "languages": [
        "python"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/github-trending-discovery-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "languages": ["python"] }

# Run the Actor and wait for it to finish
run = client.actor("maydit/github-trending-discovery-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "languages": [
    "python"
  ]
}' |
apify call maydit/github-trending-discovery-monitor --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/x4kyz1xYnSJdEo3WD/builds/9fuSGfN3yahvl0haJ/openapi.json