# 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
- **Stats:** 2 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

## GitHub Repo Intel — search, stars, activity, contributors, health

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. |
| `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) |
| `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` |
| `includeLatestCommit` | boolean | false | `latestCommit` + `totalCommits` |
| `includeCommunityProfile` | boolean | false | `community.*` health flags |
| `includeIssuePrSplit` | boolean | false | `openIssuesOnly`, `openPullRequests` (2 search requests per repo) |
| `includeReadme` | boolean | false | First 4000 chars of README |
| `fields` | string\[] | all | Whitelist of top-level output fields (`id`, `fullName`, `url`, `fetchedAt` always kept) |
| `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. Invalid repo references, dates or enum
values fail the run immediately with a message listing every problem.

### 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.

### Examples

**Vet three dependencies before adopting them**

```json
{ "repos": ["hono-dev/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. Failed or missing references (404, 5xx after retries) 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`, `daysSinceRelease` | | With `includeReleases` (drafts skipped; `latestRelease` prefers non-prerelease) |
| `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 while GitHub is still computing) |
| `latestCommit{sha,date,author,message,url}`, `totalCommits` | | With `includeLatestCommit` |
| `community{healthPercentage,hasReadme,hasLicense,hasContributing,hasCodeOfConduct,hasIssueTemplate,hasPullRequestTemplate}` | object | With `includeCommunityProfile` |
| `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`, `requests`), `STATS` (`pushed`, `failed`, `requests`, `coreRemaining`, `searchRemaining`) and, on a
rate-limit abort, `RATE_LIMIT` with the reset time. The run fails only when nothing could be fetched.

### 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**. Error items (404, invalid ref) are pushed
but count as items too, so validate references upstream when possible.

Typical runs: vetting 3 dependencies ≈ $0.016; a 50-repo market scan ≈ $0.25; a 200-repo org inventory ≈ $1.00.
Apify compute (256 MB, seconds per run) is billed separately by the platform.

### Limits & FAQ

- **Rate limits.** Without a token GitHub allows 60 core requests/h and 10 search requests/min per IP — enough for ~10 fully
  enriched repos or a few hundred un-enriched search results per hour. When the quota is exhausted the run **fails fast**
  with the reset time (no silent looping); everything fetched so far stays in the dataset. 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).
- **Commit activity is null.** GitHub computes `/stats/commit_activity` lazily and answers 202 for cold repositories. The actor
  retries 4 times (~20 s); if still not ready you get nulls and a warning — run again a minute later.
- **`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.

## `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). 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` 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; for a cold repo the first call may return nothing (the actor retries a few times, then leaves nulls and warns).

## `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`: 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 queries per repo to fill `openIssuesOnly` and `openPullRequests`. Costs the search-API quota (10 requests/min without token, 30 with) — enable for small batches or with a token.

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

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

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

Optional whitelist of top-level output fields (e.g. `["stars","forks","pushedAt","commits4w"]`). `id`, `fullName`, `url`, `fetchedAt` are always kept. Empty = all fields.

## `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.

## 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

## `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/1q5epCcfpLu8sLMHa/openapi.json