# GitHub Repo Intel — Search, Stars, Activity, Contributors (`yadroo/github-repo-intel`) Actor

GitHub repository intelligence for AI agents and analysts: explicit repos, repository search with qualifiers (stars, language, topic, dates, license), org/user listings.

- **URL**: https://apify.com/yadroo/github-repo-intel.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 result 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/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

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.

> **Need it tailored to your workflow?** Missing a field, a filter, another source or a different output format? [Open an issue](https://apify.com/yadroo/github-repo-intel/issues) and describe what you need — we read every request and adapt the actor.

### 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](#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**

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

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

```json
{ "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**

```json
{ "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**

```json
{ "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**

```json
{ "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:

```json
{
  "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

```bash
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}'
```

```js
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();
```

```python
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](https://apify.com/yadroo/npm-package-intel) ·
[pypi-package-intel](https://apify.com/yadroo/pypi-package-intel) ·
[hackernews-search](https://apify.com/yadroo/hackernews-search) ·
[stackexchange-search](https://apify.com/yadroo/stackexchange-search) ·
[domain-intel](https://apify.com/yadroo/domain-intel)

# Actor input Schema

## `repos` (type: `array`):

Explicit repositories to analyse. Accepts `owner/repo`, full github.com URLs (sub-paths, `.git`, query strings are tolerated) or `git@github.com:owner/repo.git`. Each is fetched with all enabled enrichments. A string that is not a repository reference is skipped and listed in `SUMMARY.errors` (not charged); the run stops before any request only when no input is usable.

## `searchQueries` (type: `array`):

GitHub repository-search queries (same syntax as github.com/search?type=repositories). Free text plus qualifiers: `stars:>500`, `language:typescript`, `topic:mcp`, `created:>=2026-01-01`, `pushed:>2026-06-01`, `license:mit`, `archived:false`, `fork:false`, `org:apify`, `user:someone`, `in:name,description,readme`, `good-first-issues:>5`, `help-wanted-issues:>0`, `is:public`, `template:false`. The structured filters below are appended automatically unless you already wrote that qualifier. Each query returns up to `maxItems` repositories (GitHub caps any search at 1000). Not code search — `path:`/`extension:` are rejected.

## `searchSort` (type: `string`):

Sort order for `searchQueries` (GitHub search API `sort`).

## `searchOrder` (type: `string`):

Direction for `searchSort`. Ignored for best-match.

## `orgs` (type: `array`):

GitHub organisation logins (e.g. `apify`, `vercel`) — lists their repositories via GET /orgs/{org}/repos, newest push first, up to `maxItems` each after filters.

## `users` (type: `array`):

GitHub user logins — lists their public repositories via GET /users/{user}/repos, up to `maxItems` each after filters.

## `listType` (type: `string`):

Which repositories to list for `orgs`/`users`. For users the API only supports all/owner/member, so `sources`/`forks`/`public` are emulated by filtering owner repos.

## `listSort` (type: `string`):

Server-side sort for `orgs`/`users` listings (descending).

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

Cap for each search query and each org/user listing (explicit `repos` are always all fetched). The run also stops at your max cost per run. Keep small without a token: each listed repo costs 0 extra requests unless `enrichListed` is on.

## `minStars` (type: `integer`):

Only repositories with at least this many stars (search: `stars:>=N`).

## `maxStars` (type: `integer`):

Only repositories with at most this many stars — useful to find early-stage projects or acquisition targets.

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

Primary language exactly as GitHub names it (e.g. `TypeScript`, `Python`, `Go`, `Rust`, `Jupyter Notebook`). Case-insensitive.

## `pushedAfter` (type: `string`):

YYYY-MM-DD. Only repositories with a commit push on/after this date (search: `pushed:>=DATE`). Good proxy for 'still maintained'.

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

YYYY-MM-DD. Only repositories created on/after this date — find new entrants in a niche.

## `excludeForks` (type: `boolean`):

Drop forked repositories (search: `fork:false`).

## `excludeArchived` (type: `boolean`):

Drop archived (read-only) repositories (search: `archived:false`).

## `enrichListed` (type: `boolean`):

Also run the enrichments below on repositories found via `searchQueries`, `orgs` and `users`. Off = only the fields GitHub returns in list responses (stars, forks, language, license, topics, dates, open issues) — zero extra requests.

## `includeReleases` (type: `integer`):

How many latest releases to include (tag, name, date, prerelease flag). Also fills `latestRelease`, `latestReleaseTag` and `daysSinceRelease`. 0 = skip.

## `includeContributors` (type: `integer`):

How many top contributors (login, commit count, bot flag) to include. Also fills `contributorsCount` (total) and `topContributorShare` (% of commits by #1 — bus-factor signal). 0 = skip.

## `includeLanguages` (type: `boolean`):

Fetch /languages → `languages` (percent by bytes) and `languageBytes`.

## `includeCommitActivity` (type: `boolean`):

Fetch weekly commit counts → `commits52w`, `commits12w`, `commits4w`, `activeWeeks52w`, `lastActiveWeek`. GitHub computes this lazily and answers "not ready yet" (HTTP 202) for a cold repository. With a token the actor asks again up to 3 times (~12 s); without a token it does not (each retry would spend the 60/h quota). Then the columns stay null and `SUMMARY.commitActivityPending` lists the repository: a cold one is usually ready a minute later, very large ones (pytorch, tensorflow) often stay unready for days.

## `includeLatestCommit` (type: `boolean`):

Fetch the latest commit on the default branch (`latestCommit`: sha, date, author, message) and derive `totalCommits` from pagination headers — one request.

## `includeCommunityProfile` (type: `boolean`):

Fetch /community/profile → `community` (and `healthPercentage` as a top-level column): health %, presence of README, LICENSE, CONTRIBUTING, code of conduct, issue/PR templates. Useful for open-source due diligence.

## `includeIssuePrSplit` (type: `boolean`):

GitHub's `openIssues` counts issues AND pull requests together. This runs two issue-search requests per repo to fill `openIssuesOnly` and `openPullRequests`. They use the search quota: 10 requests a minute without a token (the run waits for the one-minute window to reset after every 5 repos), 30 with one.

## `includeReadme` (type: `boolean`):

Decode the repository README and include the first 4000 characters as `readme` plus `readmeUrl`.

## `fields` (type: `array`):

Optional list of top-level output columns, in the order you want them (e.g. `["stars","forks","pushedAt","commits4w"]`). `id`, `fullName`, `url` and `fetchedAt` are always kept (first, unless you list them elsewhere). Another letter case or a near-miss typo with one candidate is corrected; a name that is not a column is skipped — both are reported in `SUMMARY.warnings`. If no name is a column, the run stops before any request with the list of columns. Empty = all columns.

## `token` (type: `string`):

Personal access token or GitHub App token (no scopes needed for public data). Raises limits from 60 to 5000 core requests/hour and from 10 to 30 search requests/minute, and lets you read private repositories you have access to. The actor works without it; without it, a used-up hourly quota ends the run early (rows saved so far are kept).

## Actor input object example

```json
{
  "repos": [
    "x402-foundation/x402",
    "apify/crawlee"
  ],
  "searchSort": "best-match",
  "searchOrder": "desc",
  "listType": "sources",
  "listSort": "pushed",
  "maxItems": 20,
  "excludeForks": false,
  "excludeArchived": false,
  "enrichListed": false,
  "includeReleases": 5,
  "includeContributors": 10,
  "includeLanguages": true,
  "includeCommitActivity": true,
  "includeLatestCommit": false,
  "includeCommunityProfile": false,
  "includeIssuePrSplit": false,
  "includeReadme": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

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

No description

## `stats` (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 = {
    "repos": [
        "x402-foundation/x402",
        "apify/crawlee"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/github-repo-intel").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 = { "repos": [
        "x402-foundation/x402",
        "apify/crawlee",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("yadroo/github-repo-intel").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 '{
  "repos": [
    "x402-foundation/x402",
    "apify/crawlee"
  ]
}' |
apify call yadroo/github-repo-intel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/github-repo-intel"
        }
    }
}
```

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/xJkD7PTRr2caz8zHP/builds/WUkVBufVpbdcyeURo/openapi.json