GitHub Repo Intel — Search, Stars, Activity, Contributors

One clean JSON per repository, built for AI agents and analysts: stars, forks, open issues split from pull requests, language breakdown, 52-week commit activity, releases, top contributors with a bus-factor signal, community-health profile and README. Feed it explicit repos, a GitHub repository search query with qualifiers, or an organisation / user to list. No API key, proxy or browser needed — works on GitHub's public REST API (60 requests/h); drop in a token for 5000/h.

Use cases

• Dependency due diligence — is this library maintained? Days since last push/release, active weeks, contributor count, top-contributor share, archived flag.
• Competitor / market scan — topic:mcp language:typescript stars:>500 pushed:>2026-06-01 sorted by stars, refreshed weekly.
• Deal sourcing — new repos in a niche (createdAfter), with maxStars to catch early-stage projects before they trend.
• Portfolio monitoring — list every repo of your orgs (orgs) and alert when daysSincePush grows or openPullRequests piles up.
• Developer-relations research — who are the top contributors of the projects your users depend on (contributors, bot-filtered).
• Open-source compliance — license SPDX id, license file presence, code-of-conduct / contributing files via the community profile.

Input

Field	Type	Default	Notes
repos	string[]	—	owner/repo, github.com URLs (sub-paths, .git, ?tab= tolerated) or git@github.com:o/r.git. Always fully enriched. A string that is not a repository reference is skipped and listed in SUMMARY.errors (not charged)
searchQueries	string[]	—	Repository search queries with qualifiers (see Reference). Up to maxItems per query, GitHub caps at 1000. Not code search.
searchSort	select	best-match	best-match, stars, forks, help-wanted-issues, updated
searchOrder	select	desc	desc, asc
orgs	string[]	—	Organisation logins → GET /orgs/{org}/repos
users	string[]	—	User logins → GET /users/{user}/repos
listType	select	sources	sources, all, public, forks, member (users: sources/forks/public emulated client-side)
listSort	select	pushed	pushed, updated, created, full_name
maxItems	integer	20	Cap per search query and per org/user (1–1000). The run also stops at your max cost per run
minStars / maxStars	integer	—	Star range; search → stars: qualifier, listings → client-side
language	string	—	Primary language as GitHub names it (TypeScript, Jupyter Notebook…)
pushedAfter / createdAfter	date YYYY-MM-DD	—	Recency filters (pushed:>=, created:>=)
excludeForks / excludeArchived	boolean	false	fork:false, archived:false
enrichListed	boolean	false	Run the per-repo enrichments also on search/org/user results (otherwise they cost zero extra requests)
includeReleases	integer	5	Latest releases (0–30) + latestRelease, daysSinceRelease
includeContributors	integer	10	Top contributors (0–100) + contributorsCount, topContributorShare
includeLanguages	boolean	true	languages (%), languageBytes
includeCommitActivity	boolean	true	commits52w/12w/4w, activeWeeks52w, lastActiveWeek (see FAQ: null while GitHub computes them)
includeLatestCommit	boolean	false	latestCommit + totalCommits
includeCommunityProfile	boolean	false	community.* health flags
includeIssuePrSplit	boolean	false	openIssuesOnly, openPullRequests (2 search requests per repo; without a token the run waits for the 1-minute search window after every 5 repos)
includeReadme	boolean	false	First 4000 chars of README
fields	string[]	all	Top-level output columns, in your order. id, fullName, url, fetchedAt are always kept (first, unless you list them elsewhere). Another letter case or a one-candidate typo (comits4w) is corrected, an unknown name is skipped — both reported in SUMMARY.warnings
token	secret string	—	GitHub PAT / App token. 60 → 5000 core req/h, 10 → 30 search req/min, private repos you can read

At least one of repos, searchQueries, orgs, users is required. The run stops before any request (a failed run: only the start event is charged), with a message listing every problem, when no input is usable (no source, or only strings that are not repository references), a date is not YYYY-MM-DD, a search uses code-search qualifiers (path:, extension:, in:file), or no name in fields is an output column. Values of the select fields (searchSort, searchOrder, listType, listSort) must be one of the listed values exactly: Apify refuses any other value before the run starts.

Reference

Repository-search qualifiers (searchQueries)

Same syntax as github.com/search?type=repositories. Combine with free text; NOT, -qualifier: and ranges (>, >=, <, ..) are supported. Structured inputs (minStars, language, pushedAfter, createdAfter, excludeForks, excludeArchived) are appended automatically unless you already used that qualifier.

Qualifier	Example	Meaning
in:	in:name,description,readme	Where the free text must match (default name + description)
user: / org:	org:vercel	Repositories owned by a user / organisation
repo:	repo:apify/crawlee	A specific repository
stars:	stars:>=1000, stars:10..500	Star count
forks:	forks:>100	Fork count
size:	size:<5000	Size in KB
language:	language:rust	Primary language
topic:	topic:mcp	Has this topic (repeatable)
topics:	topics:>3	Number of topics
license:	license:mit, license:apache-2.0	License keyword (SPDX-like, lower-case)
created: / pushed:	created:>=2026-01-01, pushed:2026-06-01..2026-09-01	Dates
is:	is:public, is:private	Visibility (private needs a token)
fork:	fork:false, fork:only, fork:true	Fork handling
archived:	archived:false	Archived state
mirror:	mirror:false	Mirrors
template:	template:true	Template repositories
good-first-issues: / help-wanted-issues:	good-first-issues:>5	Issues with those labels
followers:	followers:>500	Owner's follower count

Full list: https://docs.github.com/en/search-github/searching-on-github/searching-for-repositories.

Sorts

Where	Values
searchSort	best-match, stars, forks, help-wanted-issues, updated
listSort	pushed, updated, created, full_name

Common license SPDX ids returned in license

MIT, Apache-2.0, GPL-3.0, GPL-2.0, LGPL-3.0, AGPL-3.0, BSD-2-Clause, BSD-3-Clause, MPL-2.0, ISC, Unlicense, CC0-1.0, EPL-2.0, BSL-1.0, NOASSERTION (custom / unrecognised), null (no license file).

Rate limits (GitHub, per IP without token / per token)

Resource	No token	With token	Used by
core	60 / hour	5000 / hour	repos, org/user listings, every enrichment
search	10 / minute	30 / minute	searchQueries, includeIssuePrSplit (2 per repo)

Cost per explicit repo with defaults = 1 + languages + commit activity + releases + contributors (+1 when the repo has more contributors than requested) ≈ 5–6 core requests. Search/org/user results with enrichListed: false cost 1 request per 100 repositories.

What the actor does at a limit:

• Search window (per minute) — or any limit that resets within ~65 s: it waits for the reset and goes on (logged; SUMMARY.rateLimitWaits). Only when the run has no time left before its timeout does it stop there.
• Hourly core quota — it stops asking at once. Rows saved so far are kept and the run ends SUCCEEDED with "Stopped early after N repo(s): GitHub's hourly request limit … resets at HH:MM UTC … Pass a GitHub token"; SUMMARY.inputsNotFinished lists what was not done. If nothing was saved, the run fails with the same message (start fee only).
• Secondary limits — waits as GitHub's Retry-After says (60 s when absent), at most 3 times per request.
• A refused token (401) — stops the run: every request would fail the same way.

Examples

Vet three dependencies before adopting them

{ "repos": ["honojs/hono", "colinhacks/zod", "apify/crawlee"], "includeCommunityProfile": true, "includeLatestCommit": true, "includeIssuePrSplit": true }

Weekly market scan: active TypeScript MCP servers with 500+ stars

{ "searchQueries": ["topic:mcp server"], "searchSort": "stars", "minStars": 500, "language": "TypeScript", "pushedAfter": "2026-06-01", "excludeForks": true, "excludeArchived": true, "maxItems": 50, "fields": ["stars", "forks", "pushedAt", "topics", "description", "searchTotalCount"] }

Deal sourcing: new Rust projects created this year that already have traction

{ "searchQueries": ["language:rust created:>=2026-01-01"], "searchSort": "stars", "minStars": 200, "maxStars": 5000, "maxItems": 100 }

Portfolio monitor: every source repo of your orgs, enriched, run daily

{ "orgs": ["x402-foundation", "apify"], "listType": "sources", "listSort": "pushed", "maxItems": 30, "enrichListed": true, "includeReleases": 3, "includeContributors": 5, "includeLatestCommit": true, "token": "ghp_…" }

Bus-factor audit of a user's projects

{ "users": ["sindresorhus"], "minStars": 1000, "maxItems": 20, "enrichListed": true, "includeContributors": 10, "includeLanguages": false }

Output

One item per repository — a repository found by several inputs is stored once. Failed, missing or malformed references (404, 5xx after retries, not owner/repo) are not items and are not charged: they are listed in the SUMMARY record (errors[{input, source, error}], notFound[{input, source}], with counts) and in the run's status message. Trimmed example:

{
  "id": 66670819,
  "fullName": "apify/crawlee",
  "url": "https://github.com/apify/crawlee",
  "apiUrl": "https://api.github.com/repos/apify/crawlee",
  "description": "Crawlee—A web scraping and browser automation library for Node.js…",
  "homepage": "https://crawlee.dev",
  "language": "TypeScript",
  "license": "Apache-2.0",
  "topics": ["apify", "crawler", "playwright", "scraping"],
  "stars": 25758, "forks": 1666, "watchers": 135, "openIssues": 137,
  "archived": false, "fork": false, "defaultBranch": "master",
  "createdAt": "2016-08-26T18:35:03Z", "pushedAt": "2026-09-11T18:42:13Z",
  "daysSincePush": 1, "ageDays": 3669,
  "latestRelease": { "tag": "v3.18.1", "publishedAt": "2026-08-12T15:39:11Z", "prerelease": false },
  "daysSinceRelease": 31,
  "releases": [{ "tag": "v4.0.0-rc.0", "publishedAt": "2026-08-13T10:14:22Z", "prerelease": true, "url": "…" }],
  "contributors": [{ "login": "mnmkng", "contributions": 1149, "bot": false }, { "login": "renovate[bot]", "contributions": 905, "bot": true }],
  "contributorsCount": 134, "topContributorShare": 29.3,
  "languages": { "TypeScript": 62, "MDX": 31.1, "JavaScript": 5.3 },
  "commits52w": 644, "commits12w": 256, "commits4w": 53, "activeWeeks52w": 50, "lastActiveWeek": "2026-09-06",
  "source": "repos", "query": null,
  "fetchedAt": "2026-09-12T23:28:59.943Z"
}

Field	Type	Description
id	number	GitHub repository id — stable across renames
fullName, name, owner{login,type,url}	string / object	Identity
url, apiUrl, homepage	string	Links (apiUrl = source endpoint)
description, topics[], language, license, licenseName		Metadata; license is the SPDX id
stars, forks, watchers, openIssues, size	number	Counters. openIssues = issues and PRs (GitHub semantics); watchers is null for search/listing items unless enriched
archived, disabled, fork, parent, isTemplate, hasIssues, hasWiki, hasDiscussions, hasPages	boolean / string	Flags
createdAt, updatedAt, pushedAt, daysSincePush, ageDays		Dates & derived recency
releases[], latestRelease, latestReleaseTag, daysSinceRelease		With includeReleases (drafts skipped; latestRelease prefers non-prerelease; latestReleaseTag = its tag as a top-level column)
contributors[], contributorsCount, topContributorShare		With includeContributors; share = % of listed commits by the #1 contributor
languages, languageBytes	object	With includeLanguages
commits52w, commits12w, commits4w, activeWeeks52w, lastActiveWeek	number / string	With includeCommitActivity (null when GitHub has not computed them — see FAQ)
latestCommit{sha,date,author,message,url}, totalCommits		With includeLatestCommit
community{healthPercentage,hasReadme,hasLicense,hasContributing,hasCodeOfConduct,hasIssueTemplate,hasPullRequestTemplate}, healthPercentage	object / number	With includeCommunityProfile (healthPercentage = a top-level copy for tables and CSV)
openIssuesOnly, openPullRequests	number	With includeIssuePrSplit
readme, readmeUrl	string	With includeReadme
source, query, searchTotalCount		repos / search / org / user; the effective query; total matches GitHub reported
fetchedAt	ISO string	When the item was fetched

The key-value store also gets:

• SUMMARY — items, errors, errorCount, notFound, notFoundCount, invalidReferences, commitActivityPending (repos whose commit stats GitHub was still computing), rateLimited ({resource, resetAt} or null), stoppedEarly, inputsNotFinished, warnings, requests, coreRemaining, coreResetAt, searchRemaining, rateLimitWaits, rateLimitWaitSec, authenticated, status, and the run's row counts (delivered, stoppedBy: limit = your max cost per run, timeout, aborted, or null);
• STATS — pushed, failed, requests, coreRemaining, searchRemaining, authenticated;
• RATE_LIMIT — the message and reset time, when GitHub's quota stopped the run.

The run fails only when nothing could be saved (a bad input, a used-up quota or a refused token before the first row, or every input failing).

Use it from code / agents

curl -X POST "https://api.apify.com/v2/acts/yadroo~github-repo-intel/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"repos":["apify/crawlee"],"includeCommunityProfile":true}'

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/github-repo-intel').call({ searchQueries: ['topic:mcp language:typescript'], minStars: 500, maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();

from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/github-repo-intel").call(run_input={"orgs": ["apify"], "maxItems": 30, "enrichListed": True})
items = client.dataset(run["defaultDatasetId"]).list_items().items

MCP: add https://mcp.apify.com to your agent (Claude, Cursor, custom) and call the tool yadroo/github-repo-intel with the same JSON input; the schema descriptions are written so an agent can fill them unaided.

Pricing

Pay per event: $0.001 per run start + $0.005 per repository item. Bronze −10 %, Silver −20 %, Gold and above −30 % on the item price; the start event is the same on every plan; platform usage is included.

Only repositories written to the dataset are charged. Missing (404), failed and malformed references are listed in SUMMARY and cost nothing. A run that saves nothing (bad input, used-up quota, refused token) fails and costs only the start fee. The run never charges more than your max cost per run: it stops there with the status "Stopped at your spending limit: N rows delivered".

Typical runs: vetting 3 dependencies ≈ $0.016; a 50-repo market scan ≈ $0.25; a 200-repo org inventory ≈ $1.00.

Limits & FAQ

• Rate limits. Without a token GitHub allows 60 core requests/h and 10 search requests/min per IP — and the Apify IP is shared, so a run often starts with fewer left. That is enough for ~7–10 fully enriched repos or a few thousand un-enriched search results per hour. The search window is waited out; when the hourly quota runs out the run stops at once with the reset time (no silent looping), keeps what it saved and ends SUCCEEDED (FAILED only if nothing was saved). Pass token for 5000/h.
• Secondary limits / 5xx. Retried with backoff (honours Retry-After, max 60 s), up to 4 attempts, then the repo is listed in SUMMARY.errors (no item, not charged). Any other 403 (a blocked repository, a contributor list too large for the API) is not retried: that sub-field stays null.
• Commit activity is null. GitHub computes /stats/commit_activity lazily and answers 202 for cold repositories. With a token the actor asks again up to 3 times (~12 s); without one it does not (each retry would spend the 60/h quota). The repository is listed in SUMMARY.commitActivityPending and the status message. A cold repository is usually ready a minute later; very large ones (pytorch, tensorflow, transformers) often keep answering 202 for days — for them these columns stay null.
• Run size and timeout. Rows are saved as they are ready (per page, or per repository when enriched). Near the run timeout the actor stops starting requests and ends SUCCEEDED with "Stopped before the run timeout: N rows saved"; after a platform migration or restart it skips the inputs it finished and never saves or charges a repository twice.
• openIssues looks too high. That is GitHub's own number: issues + pull requests. Enable includeIssuePrSplit for the split.
• Freshness. Live API calls on every run; counters are current to the second, search indexes lag by minutes.
• Private repositories. Only with a token that can read them; is:private search also needs a token.
• Code search / user search. Not included: code search requires authentication on GitHub's side and returns file matches, not repositories. Use searchQueries with in:readme for text-in-repo discovery.
• Roadmap. Star history sampling via stargazers timestamps; dependents count; issue response-time metrics.

---

Made by Yadroo — more data actors for agents: npm-package-intel · pypi-package-intel · hackernews-search · stackexchange-search · domain-intel