# GitHub Intel: Repos, Developer Leads & Stargazer Lists (`obsidian937/github-intel`) Actor

Turn GitHub into structured B2B data. Search repositories by language, topic or stars; build developer lead lists by location and language; or export a repo's stargazers and contributors as enriched leads. Official GitHub REST API, no proxy. Delta mode for recurring monitoring.

- **URL**: https://apify.com/obsidian937/github-intel.md
- **Developed by:** [Obsidian IT Consulting SRL](https://apify.com/obsidian937) (community)
- **Categories:** Developer tools, Lead generation, Jobs
- **Stats:** 9 total users, 1 monthly users, 96.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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 Intel: Repos, Developer Leads & Stargazer Lists

Turn GitHub into structured, B2B-ready data. Three modes in one actor, built on the official GitHub REST API. No proxy, no scraping of HTML, no breakage.

Bring your own read-only GitHub token (optional but recommended): it lifts the rate limit from 60 to 5000 requests per hour. No special scopes are needed for public data.

### What it does

#### 1. Repositories (intel)

Search repositories by language, topic, minimum stars, or creation date. Every result is a clean row:

- `fullName`, `owner`, `ownerType`, `description`
- `language`, `topics`, `license`, `homepage`
- `stars`, `forks`, `watchers`, `openIssues`
- `createdAt`, `updatedAt`, `pushedAt`, `url`

Use it for competitive intel, ecosystem mapping, or finding fast-growing projects in your space.

#### 2. Developer leads (users)

Find developers by `location`, `language`, and `minFollowers`. With `enrichProfiles` on, each result is a full lead:

- `login`, `name`, `company`, `location`
- `email` and `blog` (when public), `twitter`
- `bio`, `hireable`, `publicRepos`, `followers`
- `url`

Ideal for dev recruiting and developer-tooling sales.

#### 3. Stargazers / contributors of a repo

Export the people behind a repository as enriched leads. Point it at any `repo` (`owner/name`) and choose `leadSource`: stargazers (warm, interested in the space) or contributors. Each lead is enriched with the same profile fields as mode 2, plus `sourceRepo`, `starredAt`, and `contributions` where available.

This is the highest-intent lead list on GitHub: the people who starred your competitor already care about the problem you solve.

Note on tokens: GitHub requires authentication on the stargazers endpoint, so `leadSource: "stargazers"` needs a `githubToken` (a read-only personal access token, no scopes). Without a token the run does not fail: it falls back to `contributors`, which is public, and every record says which `leadSource` it came from.

### Running without a token

Every mode returns data anonymously, and no input combination fails the run:

- Anonymous callers get 60 GitHub requests per hour, so profile enrichment is budgeted. The run enriches as many leads as the quota allows, emits the rest as `login` + `url`, and flags each record with `enriched: true` or `false`. It never dies mid-run on a rate limit.
- `stargazers` without a token falls back to `contributors`.
- `users` with no filter runs a broad demo query, and `stargazers` with no repo runs a demo repository, so clicking Start on the default form always returns rows.

Add a read-only `githubToken` to lift the quota to 5000 requests per hour: every lead comes back fully enriched, and the stargazer list becomes available.

### Delta / monitor mode

Set `deltaMode: true` to only emit items new since the previous run. State is stored per Apify account.

- Repos: repositories with new activity (a push) since the last run.
- Stargazers: it resumes from where the last run stopped, so the same stargazers are never pulled twice.

Pair it with a schedule and a webhook for recurring alerts on active projects or fresh leads. This is recurring usage, not a one-shot scrape.

### Example inputs

Fast-growing Rust repositories created this year:

```json
{ "mode": "repos", "language": "Rust", "minStars": 100, "createdAfter": "2026-01-01", "sort": "stars" }
```

Swift developers in Brussels with a following:

```json
{ "mode": "users", "language": "Swift", "location": "Brussels", "minFollowers": 50, "enrichProfiles": true }
```

Enriched leads from a competitor's stargazers, only new stars each run:

```json
{ "mode": "stargazers", "repo": "owner/their-product", "enrichProfiles": true, "deltaMode": true }
```

### Who uses this

- Recruiters and sourcers building structured developer pipelines
- Developer-tooling and SaaS teams running competitive and ecosystem intel
- Sales teams turning stargazers and contributors into warm leads

### Founder / VC / Sales data suite

Part of a B2B data suite. Pair with our other actors for full coverage:

- **Hacker News Intel** (Who is hiring jobs, Show HN launches, keyword monitor)
- **Y Combinator Companies Scraper** (startups by batch, industry, region)
- **IndieHackers Product Scraper** (products, revenue, founders)
- **BetaList Startup Scraper** (upcoming launches and makers)

### Notes

- Search modes return up to 1000 results (a GitHub API limit). Narrow your query for full coverage of a large space.
- The actor respects GitHub rate limits and waits for resets automatically. Providing a token avoids almost all waiting.
- Only public data is returned. Email and company appear only when the user has made them public.

# Actor input Schema

## `mode` (type: `string`):

What to extract: repositories, developer leads, or a repo's stargazers/contributors as leads.

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

A read-only GitHub personal access token. Needed for the stargazers lead source (GitHub returns 401 to anonymous callers there; without a token the run falls back to contributors), and strongly recommended everywhere else: it lifts the rate limit from 60 to 5000 requests/hour, so every lead gets a full profile. No scopes needed for public data.

## `searchQuery` (type: `string`):

Raw GitHub search query, e.g. "language:rust stars:>1000" (repos) or "location:Berlin language:Go" (users). Overrides the structured filters below.

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

Programming language filter, e.g. "Rust", "Swift", "Go" (repos and users modes). Users mode with no filter at all runs a demo query.

## `topic` (type: `string`):

Repository topic, e.g. "cli", "machine-learning" (repos mode).

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

Only repositories with at least this many stars (repos mode).

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

Only repositories created on/after this date, e.g. "2026-01-01" (repos mode).

## `location` (type: `string`):

Developer location, e.g. "Brussels", "San Francisco" (users mode).

## `minFollowers` (type: `integer`):

Only developers with at least this many followers (users mode).

## `userType` (type: `string`):

Restrict to individual users or organizations (users mode).

## `repo` (type: `string`):

Target repository for stargazers mode, e.g. "sindresorhus/awesome". Left empty, the run uses a demo repository.

## `leadSource` (type: `string`):

Whether to read the repo's stargazers or its contributors (stargazers mode). Stargazers needs a githubToken; without one the run automatically falls back to contributors, which is public. Every record carries the leadSource actually used.

## `enrichProfiles` (type: `boolean`):

Fetch each lead's full profile (name, company, location, email, blog, followers). Costs one GitHub request per lead, so without a githubToken only the first leads are enriched (60 requests/hour) and the rest are emitted as login + URL. Each record carries an "enriched" flag.

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

Sort order for results (repos / users modes).

## `deltaMode` (type: `boolean`):

Only emit items new since the previous run (per-account state). Repos: repositories with a new push. Stargazers: resumes where the last run stopped, never pulling the same lead twice. Pair with a schedule + webhook for recurring alerts.

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

Cap on records to return. Search modes are capped at 1000 by the GitHub API.

## Actor input object example

```json
{
  "mode": "repos",
  "searchQuery": "",
  "language": "",
  "topic": "",
  "minStars": 0,
  "createdAfter": "",
  "location": "",
  "minFollowers": 0,
  "userType": "",
  "repo": "sindresorhus/awesome",
  "leadSource": "stargazers",
  "enrichProfiles": true,
  "sort": "stars",
  "deltaMode": false,
  "maxItems": 100
}
```

# Actor output Schema

## `records` (type: `string`):

One dataset item per GitHub record. Repository items (source=repo): fullName, owner, ownerType, name, description, language, topics, stars, forks, watchers, openIssues, license, homepage, isFork, archived, createdAt, updatedAt, pushedAt, url. Lead items (source=user): login, name, type, company, location, email, blog, twitter, bio, hireable, publicRepos, followers, following, createdAt, url, enriched, plus sourceRepo, leadSource, starredAt and contributions when the lead comes from a repository.

# 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 = {
    "repo": "sindresorhus/awesome"
};

// Run the Actor and wait for it to finish
const run = await client.actor("obsidian937/github-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 = { "repo": "sindresorhus/awesome" }

# Run the Actor and wait for it to finish
run = client.actor("obsidian937/github-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 '{
  "repo": "sindresorhus/awesome"
}' |
apify call obsidian937/github-intel --silent --output-dataset

```

## MCP server setup

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