# GitHub Repos, Trending & Releases API — No Token Needed (`insight.solutions/github-repos-api`) Actor

GitHub repository facts — stars, forks, watchers, issues, language, licence, topics, README — plus trending repos by language, search in GitHub's syntax, releases with download counts and organisation repos. No token needed. No user or profile scraping. $1 per 1,000 repositories.

- **URL**: https://apify.com/insight.solutions/github-repos-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Developer tools, AI, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 repositories

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 Repos, Trending & Releases API — No Token Needed

Repository facts — stars, forks, watchers, open issues, language, licence,
topics, dates, and the README on request — plus **GitHub trending** for any
language and period, **repository search** in GitHub's own query syntax,
**releases** with assets and download counts, and an **organisation's
repositories**. All as rows in one schema, and no token needed for small runs.

Read from GitHub's REST API (`api.github.com`) and, where GitHub only publishes
HTML, from `github.com` — the trending page, and two fallbacks for when the
API's anonymous limit is reached.

> **The honest part first.** Without a token, GitHub allows **60 requests an
> hour per IP address** to its API, and **10 searches a minute**. That is what
> GitHub's own `/rate_limit` endpoint reported for this Actor's capture, through
> the proxy and without it. It is plenty for the default run (2 of the 60) and
> for a few dozen repositories; for hundreds, add your own free token and the
> limit becomes **5,000 an hour**. When the limit is reached anyway, the Actor
> does not just stop — see *[When GitHub says "rate limit exceeded"](#when-github-says-rate-limit-exceeded)*.

### At a glance

**Input** — this is the Store prefill; paste it and run:

```json
{ "repos": ["apify/crawlee", "https://github.com/microsoft/playwright"], "trending": ["all"], "trendingSince": "daily" }
```

Two repositories and today's trending list: 2 API requests and 1 page, a few
seconds, about a cent.

**Output** — one row per repository, search hit, trending repository or
release, with the same columns on every row. The ones you will use most are
`fullName`, `stars`, `forks`, `language`, `license`, `topics`, `pushedAt` and
`url`; trending rows add `starsToday`, release rows add `tag`, `publishedAt`
and `assets`. Anything that could not be read comes back as a free diagnostic
row (`rowType: "diagnostic"`, `errorType`, `error`) instead of a charge.

**Price** — **$1 per 1,000 repositories** on the FREE tier, $0.30 per 1,000
search results, $0.50 per 1,000 trending repositories, $0.30 per 1,000
releases, plus $0.001 per run charged only once a run has returned a row.
Diagnostic rows, rate-limited requests, repositories that do not exist,
duplicates and empty searches are free, and a run that returns nothing bills
nothing. Pay-per-event, no browser, limited permissions — works over the Apify
MCP server (`mcp.apify.com`) and with agentic (x402) payments.

**From code** —
`client.actor("insight.solutions/github-repos-api").call(run_input={…})` with
`apify-client`, or `POST
https://api.apify.com/v2/acts/insight.solutions~github-repos-api/run-sync-get-dataset-items`.

***

### What you get

A **repository** (`repos` and `orgs`):

```json
{
  "rowType": "repo",
  "source": "api.github.com",
  "fullName": "apify/crawlee",
  "owner": "apify",
  "ownerType": "Organization",
  "repoId": 66670819,
  "url": "https://github.com/apify/crawlee",
  "homepage": "https://crawlee.dev",
  "description": "Crawlee—A web scraping and browser automation library for Node.js to build reliable crawle…",
  "language": "TypeScript",
  "topics": ["apify", "automation", "crawler", "crawling", "headless"],
  "license": "Apache License 2.0",
  "licenseSpdx": "Apache-2.0",
  "stars": 25991,
  "forks": 1688,
  "watchers": 136,
  "openIssues": 136,
  "size": 175831,
  "defaultBranch": "master",
  "archived": false,
  "isFork": false,
  "createdAt": "2016-08-26T18:35:03.000Z",
  "pushedAt": "2026-10-05T18:33:18.000Z",
  "hasDiscussions": true,
  "viaHtmlFallback": false
}
```

A **trending repository** (`trending`):

```json
{
  "rowType": "trending-repo",
  "source": "github.com",
  "fullName": "tester-army/e2e",
  "description": "Next generation e2e testing framework for web and mobile apps.",
  "language": "TypeScript",
  "stars": 4644,
  "forks": 193,
  "starsToday": 1430,
  "trendingPeriod": "daily",
  "trendingLanguage": "all",
  "rank": 1
}
```

A **search result** (`searchQueries`):

```json
{
  "rowType": "search-result",
  "query": "topic:web-scraping",
  "rank": 1,
  "totalCount": 21549,
  "fullName": "firecrawl/firecrawl",
  "stars": 188896,
  "forks": 10029,
  "language": "TypeScript",
  "license": "GNU Affero General Public License v3.0",
  "pushedAt": "2026-10-05T22:40:01.000Z",
  "incompleteResults": false
}
```

A **release** (`includeReleases`):

```json
{
  "rowType": "release",
  "fullName": "apify/crawlee",
  "releaseId": 399016570,
  "tag": "v3.18.2",
  "releaseName": "v3.18.2",
  "isPrerelease": false,
  "publishedAt": "2026-09-29T09:58:35.000Z",
  "url": "https://github.com/apify/crawlee/releases/tag/v3.18.2",
  "notes": "## [3.18.2](https://github.com/apify/crawlee/compare/v3.18.1...v3.18.2) (2026-09-29)\n\n### …",
  "notesFormat": "markdown",
  "assets": [],
  "assetCount": 0,
  "totalDownloads": 0,
  "tarballUrl": "https://api.github.com/repos/apify/crawlee/tarball/v3.18.2",
  "viaAtomFallback": false
}
```

Assets carry `{ name, size, downloads, url, contentType }` each, and
`totalDownloads` sums them. (Crawlee publishes to npm, so its releases have
none.)

***

### Quick start

| You want | Input |
|---|---|
| Stars, forks and licence for a list of repositories | `{ "repos": ["apify/crawlee", "vercel/next.js", "https://github.com/microsoft/playwright"] }` |
| Today's trending repositories, all languages | `{ "trending": ["all"] }` |
| This week's trending Python and Rust | `{ "trending": ["python", "rust"], "trendingSince": "weekly" }` |
| The most-starred web-scraping repositories | `{ "searchQueries": ["topic:web-scraping"], "searchSort": "stars", "maxResults": 100 }` |
| Rust projects pushed this month with 500+ stars | `{ "searchQueries": ["language:rust stars:>500 pushed:>2026-09-01"] }` |
| Everything an organisation publishes | `{ "orgs": ["apify"], "maxResults": 200 }` |
| Releases and download counts for your dependencies | `{ "repos": ["cli/cli", "nodejs/node"], "includeReleases": true, "maxReleasesPerRepo": 20 }` |
| README text for an LLM pipeline | `{ "repos": ["apify/crawlee"], "includeReadme": true, "maxTextChars": 50000 }` |
| A big run | add `"githubToken": "<your token>"` to any of the above |

***

### Use cases

- **Track open-source projects** — stars, forks, open issues and last push for the repositories you depend on or compete with, on a schedule.
- **Spot what is rising** — the trending lists give the stars gained today, this week or this month, per language, ranked as GitHub ranks them.
- **Build a dataset** — any GitHub search (`topic:`, `language:`, `stars:`, `pushed:`, `org:`, `in:description`) as rows, with the rank and the total match count.
- **Watch releases** — new versions with their notes, prerelease flag and, where a project ships binaries, per-asset download counts.
- **Feed an LLM or an agent** — repository facts plus the README text, one flat JSON array, no browser.

***

### When GitHub says "rate limit exceeded"

Every API response tells the caller how much of its quota is left. When it
runs out, GitHub answers **403** with `x-ratelimit-remaining: 0` and the time it
resets. This Actor reads that before doing anything else, and then:

1. **Rotates the proxy session once.** Without a token GitHub counts per IP,
   and a fresh proxy session is a different exit IP with its own allowance. An
   exit that has already said "0 left" is rotated away from *before* the next
   request, so no request is wasted on a refusal it could predict.
2. **Falls back, where GitHub publishes the same facts unmetered:**
   - a **repository** is read from its github.com page — stars, forks, watchers,
     open issues, licence, topics, homepage, default branch and creation date,
     exact (the page carries `stargazerCount: 25993` even where it displays
     "26k"). Such a row has `viaHtmlFallback: true` and no `language`, `size`,
     `pushedAt` or `has*` columns, because the page does not carry them;
   - **releases** are read from the repository's `releases.atom` feed. Such a
     row has `viaAtomFallback: true`; the feed holds only the **newest ten**
     releases, carries **no assets and no download counts**, and dates each
     release by its last update, so `publishedAt` is null and the date is in
     `updatedAt`.
3. **Otherwise** — a search, an organisation listing, a README, a language
   breakdown — returns a **free `rate-limited` row with `resetAt`**, the time
   GitHub said the quota comes back, and the rest of the run carries on. Rows
   already returned are kept.

After two refusals in a row *from fresh exits*, the Actor stops asking the API
until the reset, because every exit it can reach is then dry. A search limit
(10 a minute) that resets within a minute is waited out when the run has the
time.

**With a token** the quota belongs to the token, not the IP, so rotating would
buy nothing and is skipped; the fallbacks still apply.

#### How much fits in one run without a token

Each repository is one API request, plus one for `includeReadme`, one for
`includeLanguages` and one per 100 releases. An organisation or a search is one
request per 100 results. Trending lists, repository pages and release feeds are
not counted at all. So: two repositories and trending — 2 of 60. Fifty
repositories with README and releases — about 150 requests, which the Actor
spreads over three proxy sessions and rotates past. **Several hundred
repositories needs a token**, or most rows will come from the page fallback.

#### The token

Optional. Create a **fine-grained personal access token** with read-only access
to public repositories and no other permissions, and paste it into
`githubToken`. It raises the limit to **5,000 an hour** and search to 30 a
minute. It is stored by Apify as a secret input, sent only to `api.github.com`
in the `Authorization` header, never logged, and never put on a row. If GitHub
refuses it (401), the run carries on without it and says so in one free row.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `repos` | string\[] | `[]` (prefill: two) | `owner/repo` or any github.com link to it → `repo` rows. Deduplicated case-insensitively |
| `orgs` | string\[] | `[]` | Organisation logins → their public repositories, most recently updated first, as `repo` rows, up to `maxResults` each |
| `searchQueries` | string\[] | `[]` | GitHub search syntax → `search-result` rows |
| `searchSort` | enum | `stars` | `stars`, `forks`, `updated`, or `best-match` (GitHub's relevance) |
| `trending` | string\[] | `[]` (prefill: `all`) | `all` or language slugs (`python`, `typescript`, `rust`) → `trending-repo` rows |
| `trendingSince` | enum | `daily` | `daily`, `weekly`, `monthly` |
| `includeReleases` | bool | false | `release` rows for every `repos` / `orgs` repository |
| `maxReleasesPerRepo` | int | 10 | Newest first |
| `includeReadme` | bool | false | README text on `repo` rows — one extra request each |
| `includeLanguages` | bool | false | Bytes per language on `repo` rows — one extra request each |
| `maxTextChars` | int | 20000 | README and release notes are cut here, with "…" |
| `maxResults` | int | 100 | Per search query, per organisation, per trending list. Max 1,000 |
| `githubToken` | string (secret) | — | Your own token: 5,000 requests an hour instead of 60 |
| `maxConcurrency` | int | 3 | Requests in flight, at most 3, 250 ms apart |
| `maxRunSecs` | int | 240 | Time budget, max 3600 |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Datacenter |

At least one of `repos`, `orgs`, `searchQueries` or `trending` is needed; a run
with none of them stops before sending a request.

***

### Output reference

`rowType` is one of five. Four are charged, one is free.

| `rowType` | Charged | What it is |
|---|---|---|
| `repo` | yes | One repository from `repos` or from an organisation's listing |
| `search-result` | yes | One repository a search returned, with `query`, `rank` and `totalCount` |
| `trending-repo` | yes | One repository on a trending list, with `starsToday`, `trendingPeriod`, `trendingLanguage` and `rank` |
| `release` | yes | One release, with `tag`, `publishedAt`, `notes` and `assets` |
| `diagnostic` | **no** | Anything that could not be read |

Every row carries `ok`, `rowType`, `input`, `error`, `errorType`, `scrapedAt`,
`source`, `sourceUrl`, and `null` in every column that does not apply — so a CSV
export is one rectangular table however the run was configured.

#### Three GitHub quirks, handled

- **`watchers` is the number of people watching.** GitHub's API also has a
  `watchers_count`, which is a legacy alias of the star count (25,991 and 25,991
  on Crawlee). This Actor never uses it: `watchers` is `subscribers_count` (136
  on Crawlee), which only the single-repository endpoint returns — so it is null
  on search and organisation rows rather than wrong.
- **`openIssues` includes open pull requests**, because that is how GitHub
  counts `open_issues_count`. On Crawlee: 96 issues + 40 pull requests = 136.
- **`size` is kilobytes** of the git repository, as GitHub reports it.

`starsToday` is named for the default daily list; on a weekly or monthly list
it is that period's gain, and `trendingPeriod` says which.

#### Diagnostic rows

`errorType` is one of:

| `errorType` | Means |
|---|---|
| `invalid-input` | An entry that is not a repository, organisation or trending list; a search query GitHub rejected (422); a token GitHub refused |
| `not-found` | GitHub answered 404 — the repository, organisation or trending language does not exist publicly |
| `rate-limited` | GitHub's quota was used up and there was no fallback; `resetAt` says when it comes back |
| `blocked` | An exit IP was refused even after one rotation |
| `http` | GitHub answered with an error (5xx after a retry, or a page that did not parse) |
| `timeout` | A request took longer than 30 seconds |
| `deadline` | The run's `maxRunSecs` ran out before this entry was read |
| `empty-search` | A search with no matches, or a trending list with nothing on it |

None of them is ever charged for. A run whose entries were all usable but
produced only these finishes **SUCCEEDED with zero results**, a status message
that says so, and a free diagnostic row per entry; nothing is charged, start fee
included. A run finishes **FAILED** only when there was nothing usable to
attempt, or the Actor itself hit an error.

***

### No people, by design

This Actor reads **repositories, never people.** A repository's owner is part
of its public name — `sindresorhus/awesome` cannot be named without
`sindresorhus` — so `owner` (the login) and `ownerType` are on every repository
row, and **nothing else about any account is**: no display name, email, bio,
avatar, location or follower count. There is no user or profile scraping,
`/users/` is never called, an organisation input that turns out to be a
personal account is refused, and the authors of releases, commits and issues
are never read. If you are looking for a tool that collects developers' emails,
this is deliberately not it.

***

### What you are never charged for

- Every `diagnostic` row.
- Repositories, organisations and trending languages that do not exist.
- Requests GitHub rate-limited or refused.
- A repository that appears twice — in `repos` and in its organisation's
  listing, or under two spellings — is returned and charged once.
- A README or a language breakdown: they ride on the repository row.
- An empty search, and anything past GitHub's 1,000-result search ceiling.
- A run that returns nothing at all: it finishes **SUCCEEDED with zero
  results** and a "0 results" status message, and bills nothing, **start fee
  included**.

***

### Pricing

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| `actor-start` | Once per run, only after the run has returned a row | $0.001 | $0.001 | $0.001 | $0.001 |
| **`repo`** | One repository, README and languages included | **$0.001** | **$0.001** | **$0.0008** | **$0.0006** |
| `search-result` | One search hit | $0.0003 | $0.0003 | $0.00024 | $0.00018 |
| `trending-repo` | One trending repository | $0.0005 | $0.0005 | $0.0004 | $0.0003 |
| `release` | One release, assets included | $0.0003 | $0.0003 | $0.00024 | $0.00018 |

**$1 per 1,000 repositories.**

| Run | Cost (FREE) |
|---|---|
| The default input — 2 repositories + 14 trending (as in the test capture) | **$0.010** |
| The default input on a day with the usual 25 trending | **$0.0155** |
| Trending (25) + 100 search results + 10 repositories with 10 releases each | **$0.084** |
| One organisation's 100 repositories | **$0.101** |
| A 1,000-result search | **$0.301** |

Charging is charge-after-push: rows are in your dataset before the event is
recorded. `ACTOR_MAX_TOTAL_CHARGE_USD` is respected — the run stops fetching when
it is reached and finishes SUCCEEDED saying so.

***

### Proxy

The default is `{ "useApifyProxy": true }` — Apify's **datacenter** pool. GitHub
answered the capture through it with the same quota numbers as with no proxy at
all. Here the proxy does real work: without a token GitHub meters per IP, so
each of the three request slots runs on its own proxy session, and a session
whose quota runs out is swapped for a fresh one. You can switch to residential;
you will not get different data. Without any proxy the run still works, but it
shares your own address's 60 an hour and has nothing to rotate to.

The run holds itself to **three requests in flight, 250 ms apart**, pauses
250–600 ms between successive pages of one search or listing, and runs searches
one at a time, because search has its own limit.

***

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions**, uses **pay-per-event** pricing and never enters Standby, so it works over the Apify MCP server and with x402 agentic payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~github-repos-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"trending":["python","rust"],"trendingSince":"weekly","maxResults":10}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/github-repos-api").call(run_input={
    "searchQueries": ["topic:web-scraping stars:>500"],
    "searchSort": "stars",
    "maxResults": 200,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "search-result":
        print(row["rank"], row["fullName"], row["stars"], row["language"],
              row["license"], row["pushedAt"], sep=" | ")
    elif row["rowType"] == "diagnostic":
        print("skipped:", row["errorType"], row["error"], row.get("resetAt"))
```

***

### FAQ

**Do I need a GitHub token?**
No. The default run uses 2 of the 60 requests an hour GitHub gives an anonymous
IP. Add your own token when you want hundreds of repositories, long release
histories or many searches.

**What happens when the anonymous limit is reached?**
The Actor rotates to a fresh proxy exit once; if that is out too, a repository
is read from its github.com page and releases from the Atom feed, and anything
else returns a free `rate-limited` row with `resetAt`. See *When GitHub says
"rate limit exceeded"*.

**Why are some `watchers` null?**
Because only the single-repository endpoint returns the real number of
watchers. Search and organisation listings carry only the legacy
`watchers_count`, which is the star count under another name, and this Actor
will not pass that off as watchers.

**Can I get more than 1,000 search results?**
Not for one query — GitHub stops there however it is paged, and its
`total_count` (23,061 for `stars:>1000 pushed:>2026-09-01`) is the number of
matches, not the number you can read. Split the query by a qualifier
(`stars:1000..5000`, `stars:>5000`; or `created:` ranges) and run the pieces.

**Does it read private repositories?**
No. Only public data, without login, whether or not you give a token.

**Does it scrape developer profiles or emails?**
No, and that is deliberate — see *No people, by design*.

**Is this affiliated with GitHub?**
No. This Actor is not affiliated with GitHub. It reads GitHub's public REST API
and public pages and links back to every repository and release on github.com.

***

### Limitations

- **The anonymous limit is GitHub's: 60 requests an hour per IP for the API,
  10 a minute for search.** The Actor works around it as described above, but a big
  run without a token will lean on the fallbacks, and fallback rows carry less.
- **Repository-page fallback rows have no `language`, `size`, `pushedAt` or
  `has*` switches** — the page does not carry them.
- **Atom-feed release rows are the newest ten only, with no assets, no download
  counts and no `publishedAt`.**
- **Search returns at most 1,000 results per query.** `totalCount` tells you how
  many there were.
- **Trending is a web page, not an API.** It usually lists 25 repositories (the
  capture this Actor was built on had 14), GitHub decides what is on it, and its
  layout can change; when the list does not parse, the run returns a free row
  saying so rather than a wrong number.
- **`openIssues` includes pull requests**, as GitHub counts it.
- **The upstream format may change.** GitHub versions its API (this Actor pins
  `X-GitHub-Api-Version: 2022-11-28`), but the trending page, repository pages
  and feeds are not versioned.

***

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs API](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events API](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

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

One repository per entry, as `owner/repo` or any github.com link to it (`https://github.com/apify/crawlee`, `…/tree/master/docs`, `git@github.com:apify/crawlee.git`). Each becomes one `repo` row: stars, forks, watchers, open issues, language, licence, topics, dates and more. Duplicates are dropped, case-insensitively.

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

Organisation logins (`apify`, `microsoft`) or their github.com links. Each returns its public repositories, most recently updated first, as `repo` rows, up to `maxResults` per organisation. Personal accounts are not listed: this Actor never reads user accounts, by design — put a person's repositories under Repositories instead.

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

GitHub repository search, in GitHub's own syntax: `topic:web-scraping stars:>500`, `language:rust pushed:>2026-09-01`, `org:apify`, `llm in:description`. Each query returns up to `maxResults` `search-result` rows with their rank and the total match count. GitHub returns at most 1,000 results per query, however it is paged.

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

`stars`, `forks` or `updated` (most recent first), or `best-match` for GitHub's own relevance ranking.

## `trending` (type: `array`):

`all` for GitHub's main trending page, or a language as it is spelled in github.com/trending/<language>: `python`, `typescript`, `rust`, `go`, `c++`, `jupyter-notebook`. Each list returns its repositories (usually 25) as `trending-repo` rows, with the stars gained in the period.

## `trendingSince` (type: `string`):

Which trending list: today's, this week's or this month's. `starsToday` on each row is the stars gained in that period.

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

Also return `release` rows — tag, name, prerelease flag, publish date, notes, assets with download counts — for every repository from Repositories and Organisations. When GitHub's API limit is reached, releases come from the repository's Atom feed instead: the newest ten, without assets or download counts, and the rows say so.

## `maxReleasesPerRepo` (type: `integer`):

Newest first. 100 per request.

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

Add the README, decoded, to each `repo` row (`readmeText`, cut to `maxTextChars`). One extra API request per repository.

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

Add `languages` — bytes of code per language, e.g. `{ "TypeScript": 4281680, "MDX": 2133590 }` — to each `repo` row. One extra API request per repository.

## `maxTextChars` (type: `integer`):

README text and release notes longer than this are cut, with a trailing "…".

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

Per search query, per organisation and per trending list. A search cannot go past 1,000 — that is GitHub's ceiling.

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

Optional. Your own GitHub personal access token — a fine-grained token with read-only access to public repositories and no other permissions is enough — raises the limit from 60 to 5,000 API requests an hour and search from 10 to 30 a minute. Sent only to api.github.com in the Authorization header; never logged and never put on a row. Leave empty for small runs.

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

At most three at a time, 250 ms apart — GitHub asks API clients not to burst. Each slot uses its own proxy session, which without a token is its own 60-an-hour allowance.

## `maxRunSecs` (type: `integer`):

The run stops reading when this runs out; rows already returned are kept, and anything not reached gets a free `deadline` row.

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

GitHub answered every capture request through the Apify datacenter proxy with the same quota numbers as with no proxy at all, so datacenter is the default. Without a token, GitHub counts requests per IP, and a fresh proxy session is a fresh allowance — the Actor rotates once when an exit runs out.

## Actor input object example

```json
{
  "repos": [
    "apify/crawlee",
    "https://github.com/microsoft/playwright"
  ],
  "orgs": [],
  "searchQueries": [],
  "searchSort": "stars",
  "trending": [
    "all"
  ],
  "trendingSince": "daily",
  "includeReleases": false,
  "maxReleasesPerRepo": 10,
  "includeReadme": false,
  "includeLanguages": false,
  "maxTextChars": 20000,
  "maxResults": 100,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Repositories, search results, trending repositories and releases from the GitHub REST API and github.com, in one schema, plus free diagnostic rows. Delivered as JSON items in the default dataset.

# 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/microsoft/playwright"
    ],
    "trending": [
        "all"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/github-repos-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/microsoft/playwright",
    ],
    "trending": ["all"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/github-repos-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/microsoft/playwright"
  ],
  "trending": [
    "all"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/github-repos-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/github-repos-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/MVMYTq4Sm1dKaMmEP/builds/SV0tn4YtKDY1EFEJE/openapi.json