# GitHub Repo API — Repo Info, README, Stars, Releases & Issues (`highbrow_fame/github-repo-api`) Actor

Repo details, stars, forks, topics, license, languages, latest releases, README, contributor count and recent commits from GitHub's public API, by name, link or search. Unofficial GitHub API.

- **URL**: https://apify.com/highbrow_fame/github-repo-api.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** Developer tools, Automation, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.30 / 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.

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 API — Repo Info, README, Stars, Releases & Issues

Everything GitHub shows about a repository as one clean JSON record: description, homepage, stars, forks, watchers, open issues and pull requests, topics, license, main language and the bytes per language, default branch, created / updated / last-push dates, the latest release and the five most recent ones, the README as Markdown, the number of contributors and — when you want them — the ten most recent commits. Look repositories up by `owner/name`, by any github.com link or git address, or find them with GitHub's own repository search ("web scraping language:javascript stars:>500"). Built on GitHub's public REST API: no token needed, and a free token makes it 80 times faster.

**Try it in 1 minute:**

1. Press **Start** — the prefilled input looks up two repositories: `apify/crawlee` (by name) and `expressjs/express` (by link).
2. Seconds later the **Output** tab shows both records with stars, forks, open issues, license, languages, topics, latest release, contributor count and the README.
3. Download JSON, CSV or Excel, or add **Search queries**, switch **Include recent commits** on and paste a **GitHub token** for runs of hundreds of repositories.

Price: **$0.30 per 1,000 repos** (one repository = one record, with README, releases, languages, contributor count and commits included when you ask for them). Repositories that do not exist, queries without matches, invalid inputs and inputs stopped by GitHub's hourly limit are free.

**Use it to:**

- Track the open-source projects you depend on: stars, open issues, last push, latest release and license, on a schedule, as a table.
- Build a market or competitor report from a search — the 100 most-starred "vector database" or "LLM agent" repositories, with positions.
- Feed an AI assistant or a RAG pipeline the README and recent commits of a repository, without browsing GitHub.
- Enrich a list of GitHub links from your CRM, a spreadsheet or a job post with structured facts: language, size, license, activity, contributors.
- Check a dependency before adopting it: is it archived, a fork, unlicensed, abandoned (last push), a one-person project (contributor count)?

### How it works

1. **Repositories**: `owner/name`, github.com links (any page of the repository — code, issues, a file — works), `git@github.com:owner/name.git` and `ssh://` / `git://` addresses are parsed and deduplicated (case-insensitively). Each is read with `GET /repos/{owner}/{name}` of GitHub's REST API v3. A renamed or moved repository follows GitHub's redirect and the record shows its current name.
2. **Search queries** go to `GET /search/repositories` with GitHub's own query syntax and qualifiers (`language:`, `stars:>`, `topic:`, `org:`, `pushed:>`, …), ordered by stars, forks, last update or best match, one page of up to **Max results** (max 100) per query, each result with its `position`. A search result already is a full repository payload, so it costs no second request.
3. **Extras**, each one more request per repository and each switchable: the README (`/readme` as raw Markdown, cut at 200 KB), the 5 most recent releases (`/releases`), the languages (`/languages`), the contributor count (`/contributors?per_page=1&anon=true` — the count is read from the paging header, so no usernames are fetched) and the 10 most recent commits (`/commits`), delivered without author names or e-mail addresses.
4. **Rate limits**: GitHub allows 60 requests an hour per IP without a token (about 12 repositories an hour with all extras on) and 5,000 an hour with one. The Actor watches the `X-RateLimit-Remaining` header after every call; when fewer than 8 requests are left it stops fetching the extras and says so in each record's `warnings`, so the repository facts keep coming; when the hour is used up and the reset is more than a minute away it does not block the run but delivers the remaining inputs as free `FAILED` records naming the reset time. A reset that is less than a minute away is simply waited for.

Requests go directly to api.github.com (no proxy, unless a connection drops); the token, when given, travels only in the request header and never appears in the results or the log. Phone numbers and e-mail addresses are removed from descriptions, READMEs and commit messages.

### Input

| Field | What it does |
|---|---|
| `repos` | Repositories to look up: `owner/name`, a github.com link or a git address, one per line. |
| `queries` | GitHub repository searches, one per line, with GitHub's qualifiers (`language:`, `stars:>500`, `topic:`, `org:`). |
| `maxResults` | Repositories per query — one search page, so up to 100 (default 10). |
| `sort` | Search order: `stars` (default), `forks`, `updated` or `best-match`. |
| `githubToken` | Optional personal access token (no scopes needed for public repositories): 5,000 requests an hour instead of 60. Stored as a secret. |
| `includeReadme` | Add the README as Markdown, up to 200 KB (default on). |
| `includeReleases` | Add the latest release and up to 5 recent ones (default on). |
| `includeLanguages` | Add `{ language: bytes }` (default on). |
| `includeContributorsCount` | Add the number of contributors — a count only (default on). |
| `includeCommits` | Add the 10 most recent commits without author data (default off). |
| `maxConcurrency` | Repositories handled at the same time (default 2). |
| `proxyConfiguration` | Used only to retry after a network error; the first try is direct. |

### Output

One record per repository:

| Field | What it is |
|---|---|
| `repo`, `url`, `owner`, `ownerType` | `owner/name`, its page, the owning account's login and whether it is a `User` or an `Organization` |
| `description`, `homepage`, `topics[]`, `license` | What it is; `license` is the SPDX id (`MIT`, `Apache-2.0`), `Other` for a custom one, null when none |
| `stars`, `forks`, `watchers`, `openIssues` | Counts; `openIssues` is GitHub's `open_issues_count`, which includes open pull requests; `watchers` is null for search results (GitHub's search payload has no such field) |
| `isFork`, `isArchived`, `defaultBranch`, `language`, `languages{}` | State, default branch, main language and bytes per language |
| `createdAt`, `updatedAt`, `pushedAt`, `size` | ISO 8601 dates and the size in KB |
| `hasWiki`, `hasPages`, `hasDiscussions` | Enabled features |
| `latestRelease`, `releases[]` | `{ tag, name, publishedAt, url, assetsCount, isPrerelease }` — the newest non-pre-release, and up to 5 recent releases newest first |
| `readme`, `readmeTruncated` | The README as Markdown and whether it was cut at 200 KB |
| `contributorsCount` | Number of contributors, anonymous ones included — no usernames |
| `commits[]` | With Include recent commits on: `{ sha, message, date, url }`, newest first, no author names or e-mails |
| `source`, `query`, `position` | `repos` or `search`, the query and the 1-based position in its results |
| `warnings[]`, `rateLimitRemaining` | Extras that were skipped or failed and why; GitHub requests left in the current hour |
| `input`, `status`, `error`, `scrapedAt` | What you gave, `OK` / `NOT_FOUND` / `NO_RESULTS` / `INVALID_INPUT` / `FAILED`, the reason, and when |

#### Example

````json
{
  "input": "https://github.com/expressjs/express",
  "source": "repos",
  "query": null,
  "position": null,
  "repo": "expressjs/express",
  "url": "https://github.com/expressjs/express",
  "owner": "expressjs",
  "ownerType": "Organization",
  "description": "Fast, unopinionated, minimalist web framework for node.",
  "homepage": "https://expressjs.com",
  "stars": 67812,
  "forks": 19540,
  "watchers": 1710,
  "openIssues": 182,
  "isFork": false,
  "isArchived": false,
  "defaultBranch": "master",
  "language": "JavaScript",
  "languages": { "JavaScript": 598231 },
  "topics": ["express", "javascript", "nodejs", "server"],
  "license": "MIT",
  "createdAt": "2009-06-26T18:56:01.000Z",
  "updatedAt": "2026-10-19T07:41:12.000Z",
  "pushedAt": "2026-10-17T14:02:55.000Z",
  "size": 11874,
  "hasWiki": true,
  "hasPages": false,
  "hasDiscussions": true,
  "latestRelease": { "tag": "5.1.0", "name": "5.1.0", "publishedAt": "2026-09-30T16:20:04.000Z", "url": "https://github.com/expressjs/express/releases/tag/5.1.0", "assetsCount": 0, "isPrerelease": false },
  "releases": [
    { "tag": "5.1.0", "name": "5.1.0", "publishedAt": "2026-09-30T16:20:04.000Z", "url": "https://github.com/expressjs/express/releases/tag/5.1.0", "assetsCount": 0, "isPrerelease": false },
    { "tag": "5.0.1", "name": "5.0.1", "publishedAt": "2026-08-02T10:11:45.000Z", "url": "https://github.com/expressjs/express/releases/tag/5.0.1", "assetsCount": 0, "isPrerelease": false }
  ],
  "readme": "[![Express Logo](https://i.cloudup.com/zfY6lL7eFa-3000x3000.png)](http://expressjs.com/)\n\nFast, unopinionated, minimalist web framework for Node.js.\n\n```js\nconst express = require('express')\n…",
  "readmeTruncated": false,
  "contributorsCount": 311,
  "commits": [
    { "sha": "9f1c2e7d3b4a5c6d7e8f9a0b1c2d3e4f5a6b7c8d", "message": "fix: handle trailing slash in router (#6210)", "date": "2026-10-17T14:02:55.000Z", "url": "https://github.com/expressjs/express/commit/9f1c2e7d3b4a5c6d7e8f9a0b1c2d3e4f5a6b7c8d" }
  ],
  "warnings": [],
  "rateLimitRemaining": 4987,
  "status": "OK",
  "error": null,
  "scrapedAt": "2026-10-19T12:00:00.000Z"
}
````

### FAQ

**Is this an official API?** No, it's an unofficial API built on public pages and endpoints — GitHub's public REST API v3, which needs no key for public repositories. The data is what github.com itself shows; this Actor only collects the six endpoints of a repository into one stable JSON record and handles GitHub's rate limits for you.

**Do I need a GitHub token?** Not for a handful of repositories: GitHub allows 60 requests an hour per IP, and a repository with all extras costs 5 of them. For more, create a personal access token (Settings → Developer settings → Personal access tokens; no scopes or permissions are needed for public data) and paste it into **GitHub token**: 5,000 requests an hour, about 1,000 repositories. The token is stored as a secret and only ever sent to api.github.com.

**What happens when the rate limit hits?** Nothing is lost silently. With fewer than 8 requests left, the extras are skipped and listed in `warnings` so the repository facts still arrive. When the hour is used up, the remaining inputs come back as free `FAILED` records with the reset time; run them again after it, or with a token.

**Why is `openIssues` higher than the Issues tab?** GitHub's API counts open issues and open pull requests together in `open_issues_count`; the Issues tab shows issues only.

**Why is a repository NOT_FOUND?** It is private, was deleted or renamed, or the spelling is off. GitHub's API answers 404 for private repositories even when they exist. A repository taken down for legal reasons (HTTP 451) is also reported as NOT_FOUND with the reason.

**Like it?** A short review on the Store page helps other people find this Actor. Something missing or broken? Tell us on the Issues tab — we read every one.

### Related Actors

- [GitHub Trending Scraper](https://apify.com/highbrow_fame/github-trending-repos) — trending repos by language and period
- [Hacker News Scraper](https://apify.com/highbrow_fame/hacker-news-stories) — stories, comments and search
- [Web Fetch API](https://apify.com/highbrow_fame/web-fetch-api) — any URL as HTML, text, Markdown or JSON
- [Article Extractor API](https://apify.com/highbrow_fame/article-extractor-api) — title, author, date and full text of any article
- [Website Tech Stack Detector](https://apify.com/highbrow_fame/website-tech-stack) — CMS, frameworks and analytics of any site

# Actor input Schema

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

Repositories to look up, one per line: owner/name (apify/crawlee), a github.com link (any page of the repo works) or a git address (git@github.com:owner/name.git). Duplicates are looked up once.

## `queries` (type: `array`):

GitHub repository searches, one per line, with GitHub's own qualifiers: "web scraping language:javascript stars:>500", "topic:llm pushed:>2026-01-01", "org:apify". Each match becomes a full repo record with its position.

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

Repositories per search query — one page of GitHub search, so at most 100.

## `sort` (type: `string`):

How search results are ordered: most stars, most forks, most recently updated, or GitHub's best match.

## `githubToken` (type: `string`):

Optional. Without a token GitHub allows 60 requests an hour per IP (about 12 repos an hour with all extras on, 10 searches a minute); a token raises that to 5,000 an hour. Any personal access token works — no scopes are needed for public repositories. It is sent only to api.github.com and never written to the results or the log.

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

Add the README as Markdown text (one extra request per repo; cut at 200 KB with readmeTruncated: true).

## `includeReleases` (type: `boolean`):

Add the latest release and up to 5 recent releases: tag, name, date, link, number of assets (one extra request per repo).

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

Add the languages with their bytes of code (one extra request per repo).

## `includeContributorsCount` (type: `boolean`):

Add the number of contributors, anonymous ones included — a count only, no usernames (one extra request per repo).

## `includeCommits` (type: `boolean`):

Add the 10 most recent commits of the default branch: sha, first line of the message, date and link — without author names or e-mails (one extra request per repo).

## `maxConcurrency` (type: `integer`):

Repositories handled at the same time. Without a token the hourly quota, not the concurrency, sets the pace; with a token 5 is safe.

## `proxyConfiguration` (type: `object`):

Used only to try again after a network error: api.github.com answers directly, so the first try of every request goes out without a proxy.

## Actor input object example

```json
{
  "repos": [
    "apify/crawlee",
    "https://github.com/expressjs/express"
  ],
  "queries": [],
  "maxResults": 10,
  "sort": "stars",
  "includeReadme": true,
  "includeReleases": true,
  "includeLanguages": true,
  "includeContributorsCount": true,
  "includeCommits": false,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every result as a JSON record, with a status for each input.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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": [
        "apify/crawlee",
        "https://github.com/expressjs/express"
    ],
    "queries": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/github-repo-api").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": [
        "apify/crawlee",
        "https://github.com/expressjs/express",
    ],
    "queries": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/github-repo-api").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": [
    "apify/crawlee",
    "https://github.com/expressjs/express"
  ],
  "queries": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call highbrow_fame/github-repo-api --silent --output-dataset

```

## MCP server setup

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

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/v7PFRpNy9bWaJ5vEk/builds/BIHxermdEq92JJoih/openapi.json