# GitHub Emerging Repositories Radar (`trovevault/github-emerging-repositories-radar`) Actor

Find and prioritize public GitHub repositories using topic fit, adoption, activity, maintenance, license, and momentum signals.

- **URL**: https://apify.com/trovevault/github-emerging-repositories-radar.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 repos

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## GitHub Emerging Repositories Radar

Find and prioritize GitHub repositories for integration, partnership, sponsorship, or monitoring.

This Actor combines GitHub Trending with repository metadata and ranks results by fit, adoption, activity, maintenance, license, and momentum. It answers: **which open source projects should I investigate next?**

### Why use GitHub Emerging Repositories Radar?

GitHub search produces a list. This Actor turns that list into a research queue:

- ranks repositories with an opportunity score from 0 to 100;
- separates active, stale, inactive, and archived projects;
- identifies early, growing, and established adoption;
- highlights declared licenses;
- adds a daily, weekly, monthly, or yearly trending signal when the repository appears on GitHub Trending;
- changes the recommended next action for integration, partnership, sponsorship, or monitoring;
- produces clean JSON rows for spreadsheets, CRM research, and downstream Apify workflows.

### What input does the GitHub repository finder accept?

The required input is one `query`, such as `browser automation`, `ecommerce scraping`, `LLM evaluation`, or `privacy analytics`.

Optional filters are `language`, `createdAfter`, `businessGoal`, and `maxResults`. `runId` is retained in `RUN_SUMMARY` for workflow reconciliation.

Example:

```json
{
  "query": "browser automation",
  "language": "JavaScript",
  "businessGoal": "integrate",
  "timeWindow": "weekly",
  "maxResults": 10
}
```

#### Input fields

| Field | Required | What it changes |
| --- | --- | --- |
| `query` | Yes | Technology, problem, or theme, such as `browser automation`. |
| `language` | No | Limits results to one primary language. |
| `businessGoal` | No | Frames the action as integration, partnership, sponsorship, or monitoring. |
| `timeWindow` | No | Uses daily, weekly, monthly, or yearly Trending signals. |
| `createdAfter` | No | Keeps repositories created after an ISO date. |
| `maxResults` | No | Controls dataset size from 1 to 100. |
| `runId` | No | Stores an external identifier in `RUN_SUMMARY`. |

### What data does the GitHub repository finder return?

Each repository becomes one dataset row:

```json
{
  "repository": "citrolabs/ego-lite",
  "url": "https://github.com/citrolabs/ego-lite",
  "description": "The fastest browser for AI agents to run browser automation...",
  "topics": ["ai-agent", "automation", "browser-automation", "codex"],
  "language": "JavaScript",
  "stars": 15106,
  "forks": 786,
  "createdAt": "2026-04-16T12:51:09Z",
  "lastActivity": "2026-09-06T04:30:02Z",
  "license": "MIT",
  "maintenanceStatus": "active",
  "adoptionTier": "established",
  "opportunityScore": 91,
  "recommendedAction": "investigate_integration",
  "reason": "Strong keyword/topic fit; active maintenance; established adoption with MIT license.",
  "evidenceTier": "public_repository_metadata"
}
```

When a repository also appears on GitHub Trending, the Actor uses that signal internally in `opportunityScore`. The selected window stays in `RUN_SUMMARY`, while the public dataset keeps consistently useful repository fields.

Scores are prioritization heuristics, not investment, legal, security, or acquisition advice. `evidenceTier` indicates that the row is based on public repository metadata; it does not certify code quality, license compliance, project governance, or future activity.

#### How the opportunity score works

The score combines:

- query fit across the repository name, description, and topics;
- adoption from stars and forks, using logarithmic scaling;
- activity recency based on the latest repository push;
- maintenance signals such as archive status and declared license metadata;
- a bounded momentum bonus when the same repository appears in the selected GitHub Trending window.

It does not inspect code, vulnerabilities, maintainers, funding, or commercial viability. Treat ranked rows as research candidates, not automatic approvals.

### Who uses this GitHub repository radar?

#### Integration research

Search for a technology category, filter by language, and prioritize active repositories with a declared license.

#### Partnership discovery

Find maintained projects with meaningful adoption that may be relevant to ecosystem or developer-relations outreach.

#### Sponsorship research

Use the sponsorship goal to create a shortlist of visible open source projects, then perform human review before contacting maintainers.

#### Recurring monitoring

Schedule weekly or monthly runs for the same themes and compare the output over time. The Actor is an on-demand discovery and ranking step; it does not itself send alerts.

### How do I run the Actor through the API?

Start a run through the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~github-emerging-repositories-radar/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"browser automation","language":"JavaScript","businessGoal":"integrate","maxResults":10}'
```

Read the default dataset with:

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~github-emerging-repositories-radar/runs/last/dataset/items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

Keep `maxResults` small for interactive workflows and increase it for broader market mapping.

### How can I use it with MCP and automation?

The Actor has no direct MCP connector or external writeback. It can be called through Apify-compatible MCP tooling or workflows. A typical pipeline runs it on a schedule, filters by `opportunityScore` or `maintenanceStatus`, and sends candidates to a review queue. Use `runId` to reconcile runs.

### How do I troubleshoot the Actor?

#### The Actor returns no repositories

Broaden `query`, remove `language`, or move `createdAfter` further back. GitHub applies search qualifiers together.

#### Trending data does not appear as separate columns

This is intentional. Sparse Trending matches affect the score internally and are summarized in `RUN_SUMMARY`.

#### A repository looks popular but ranks below another project

Stars are only one component. Read `reason`, `maintenanceStatus`, `createdAt`, and `lastActivity` together.

#### The license field is empty or says `NOASSERTION`

No clear SPDX license was returned. Do not interpret an empty value as permission to reuse the code.

#### The run hits a GitHub API limit

Wait for the GitHub rate-limit window and retry with fewer results.

### Limitations

- Discovery combines the public GitHub Trending page with the public GitHub repository API and its indexed metadata.
- The Actor does not clone repositories, inspect source code, evaluate security, contact maintainers, or verify sponsorship availability.
- GitHub search and API limits apply. A single run intentionally keeps the request footprint small.
- Opportunity scores are explainable heuristics using keyword fit, stars, forks, recent activity, archive state, and license metadata.
- A missing license is a research signal, not a legal conclusion.
- Public repository metadata may change between runs.
- GitHub Trending does not provide arbitrary keyword search, so theme searches use the GitHub API while Trending contributes momentum when a result matches.

### FAQ

#### Does it search repository topics?

Yes. GitHub search covers the query against repository metadata, and returned topic labels are included when available.

#### Can I use it for private repositories?

No. This version is scoped to public repository discovery and does not request or store GitHub credentials.

#### Is this a talent finder?

No. It does not collect contributor profiles, emails, or personal contact information.

#### Is it legal to use?

Use the public API responsibly and follow GitHub's terms, rate limits, and applicable laws. The Actor is not legal advice and does not certify a downstream use.

#### Does it contact maintainers or send sponsorship messages?

No. It produces a research shortlist only. It does not collect personal contact details or perform outreach.

### Feedback and support

Report unexpected results through the Actor's Issues tab with the input, run ID, and one example repository. Never include access tokens. No upstream Actor is required.

### Changelog

#### 0.1.0

- Initial public repository discovery and opportunity ranking workflow.

# Actor input Schema

## `query` (type: `string`):

Searches repository names, descriptions, and README-relevant metadata. Examples: browser automation, ecommerce scraping, LLM evaluation, privacy analytics.

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

Limits results to one primary programming language. Examples: JavaScript, Python, Go, and Rust. If omitted, repositories in any language are eligible.

## `businessGoal` (type: `string`):

Changes each repository's recommended action: integrate, partner, sponsor, or monitor. Default: integrate.

## `timeWindow` (type: `string`):

Period used for the internal GitHub Trending signal. Use daily for fresh signals, weekly for a balanced scan, monthly for broader trends, or yearly for durable projects. Default: weekly.

## `createdAfter` (type: `string`):

Keeps repositories created on or after an ISO 8601 date such as 2025-01-01. If omitted, no creation-date filter is applied.

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

Maximum number of ranked repositories to return, from 1 to 100. Use 10 for a quick shortlist or 100 for wider mapping. Default: 25.

## `runId` (type: `string`):

External workflow identifier copied into RUN\_SUMMARY for reconciliation. If omitted, no external run identifier is recorded.

## Actor input object example

```json
{
  "query": "browser automation",
  "language": "JavaScript",
  "businessGoal": "integrate",
  "timeWindow": "weekly",
  "maxResults": 10
}
```

# Actor output Schema

## `datasetUrl` (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 = {
    "query": "browser automation",
    "language": "JavaScript",
    "businessGoal": "integrate",
    "timeWindow": "weekly",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/github-emerging-repositories-radar").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 = {
    "query": "browser automation",
    "language": "JavaScript",
    "businessGoal": "integrate",
    "timeWindow": "weekly",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/github-emerging-repositories-radar").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 '{
  "query": "browser automation",
  "language": "JavaScript",
  "businessGoal": "integrate",
  "timeWindow": "weekly",
  "maxResults": 10
}' |
apify call trovevault/github-emerging-repositories-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,trovevault/github-emerging-repositories-radar"
        }
    }
}

```

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/4Zl7Lrya5TPvGPStT/builds/h37d1JzEUX8nGazx4/openapi.json