# GitHub Org / Dev-Tool Company Lead Extractor (`ayeeyee/github-org-devtool-lead-extractor`) Actor

Verified dev-tool / SaaS company leads from GitHub: MX/DNS emails + phones + socials + tech stack scraped from the org's OWN declared website, an A-D lead score, repo traction (stars + recency), an is\_verified trust signal, and an org-readiness grade. No API keys, no proxy. Per-result pricing.

- **URL**: https://apify.com/ayeeyee/github-org-devtool-lead-extractor.md
- **Developed by:** [Virtual Footprint LLC](https://apify.com/ayeeyee) (community)
- **Categories:** Lead generation, Business, Marketing
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 org lead with contacts

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## GitHub Org / Dev-Tool Company Lead Extractor

Turn GitHub into **verified dev-tool / SaaS-company sales leads** — MX/DNS-validated contact emails, phones, social profiles, tech stack and an A–D lead score, all scraped from the organization's **OWN declared website** (`/orgs/{login}` `blog` field), plus the org's repo traction (total stars / newest push / top repos), an `is_verified` trust badge, an org-readiness grade, and an "actively maintained within the window" signal.

> Per-result pricing. You're charged only when an org returns a real contact signal — not for empty lookups. No API keys, no proxy required (GitHub's REST API is a public keyless endpoint). Supply your own optional GitHub token to lift the keyless rate limit from 60 req/hr to 5,000/hr for larger batches.

### Why this exists

GitHub is the largest dev-tool / SaaS company directory on the planet — every dev-tool company has a GitHub organization namespace. Existing GitHub Apify actors are **raw profile/email scrapers** — they dump usernames or commit metadata and stop there. **None produce verified B2B sales leads.** This actor is the only one that turns GitHub Organization owners into ready-to-pitch company leads: it discovers repos by topic/language/star qualifiers, rolls them up to Organization-typed owners, walks to the org's own declared `blog` company website, and verifies a real business contact there (MX/DNS-checked email, phone, socials, tech stack) — the data a B2B sales team actually buys.

Incumbents (raw scrapers, none verified-contact lead-gen): `louisdeconinck/github-email-scraper` (5,587 totalRuns, no rating), `kawsar/github-profile-scraper` (1,139 runs), `viralanalyzer/github-trending-scraper` (376 runs).

### What it does

For each GitHub Organization:

1. **Discovers** repos via GitHub's keyless `/search/repositories?q=...` (topic/language/star/pushed qualifiers) and/or resolves explicit org-logins/URLs. The search response carries `owner.type` directly, so the Organization gate needs no extra call.
2. **Keeps only Organization-typed owners** — User/personal-account owners are dropped (the ToS-clean gate identical to the Show-HN / HuggingFace individual-author skip). GitHub user/org emails are **never** mined.
3. **Resolves the org** via `/orgs/{login}`, which returns the org's **OWN declared `blog`** company website (e.g. `vercel` → vercel.com, `puppeteer` → pptr.dev) + `is_verified` trust signal + `followers`/`public_repos`/`created_at` + `company`/`location`/`twitter_username`.
4. **Filters honestly**: orgs **without a declared `blog`** are dropped (no company website to enrich → not billed) — the data-driven equivalent of Docker Hub's bare-official-image drop. Verified-only is optional.
5. **Enriches the org's own website** with the shared enrichment layer — MX/DNS-verified emails, NANP phones, socials, tech stack, A–D lead score. The `/orgs` `email` public-profile address is deliberately **not** surfaced — contact always comes from the org's own declared site (ToS-clean, identical to the App-Store `sellerUrl` / Steam `website` / Docker Hub `profile_url` / JetBrains `vendor.url` pattern).
6. **Rolls up** all of an org's discovered repos into one lead (total stars, newest push, top repos) and emits an **org-readiness** grade (verified badge + traction + catalog + followers + reachability + maintenance recency → A–D) + a `newlyActive` flag.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | `["topic:developer-tools+stars:>500"]` | GitHub search qualifiers passed to `/search/repositories` (e.g. `"topic:developer-tools+stars:>500"`, `"language:rust+stars:>1000"`, `"topic:llm stars:>200"`). |
| `orgs` | array | `[]` | Explicit GitHub org logins (e.g. `vercel`) or `github.com/{org}` URLs. |
| `maxPerQuery` | int | `25` | Cap on repos per search query (1–100). Keyless core limit = 60 req/hr → keep totals modest; supply a token for 5,000/hr. |
| `organizationsOnly` | bool | `true` | Keep only Organization-typed owners (User owners dropped — ToS-clean gate). |
| `blogOnly` | bool | `true` | Keep only orgs that declared their own `blog` website (the clean hop). Orgs without one are dropped, not billed. |
| `verifiedOrgsOnly` | bool | `false` | Keep only `is_verified` orgs. |
| `activeWithinDays` | int | `0` | Flag orgs whose newest repo `pushed_at` is within the trailing N days as `newlyActive` (0 = off). `pushed_at` is the newest repo activity, so this is an *actively maintained within the window* signal, not a *created within the window* claim. |
| `verifyEmails` | bool | `true` | MX/DNS-validate the best contact email's domain. |
| `githubToken` | string | `""` | Your own optional GitHub PAT (public-read). Empty = keyless (60 req/hr); your token lifts to 5,000/hr. This is YOUR token, entered by you — never stored by us. |
| `concurrency` | int | `3` | Parallel orgs/repos (1–8). Lower if you hit rate limits. |
| `proxyConfiguration` | object | `{}` | Optional — only if you hit IP rate limits. |

Provide **either** `searchQueries` **or** `orgs` (or both).

### Output (per org lead)

```json
{
  "orgLogin": "TheAlgorithms",
  "orgName": "The Algorithms",
  "orgBlog": "https://the-algorithms.com/",
  "isVerified": true,
  "company": null,
  "location": "India",
  "twitterUsername": "the_algorithms",
  "followers": 63118,
  "publicRepos": 44,
  "orgCreatedAt": "2016-07-16T08:17:02Z",
  "orgHtmlUrl": "https://github.com/TheAlgorithms",
  "repoCount": 1,
  "totalStars": 222867,
  "newestPush": "2026-07-11T00:39:35+00:00",
  "topRepos": [{"name": "TheAlgorithms/Python", "stars": 222867, "pushedAt": "2026-07-11T00:39:35Z", "language": "Python", "description": "All Algorithms implemented in Python", "repoUrl": "https://github.com/TheAlgorithms/Python"}],
  "newlyActive": true,
  "emails": ["hello@the-algorithms.com"],
  "emailVerified": true,
  "phones": [],
  "socials": {"twitter": "https://twitter.com/the_algorithms", "linkedin": "https://www.linkedin.com/company/thealgorithms"},
  "techStack": ["Cloudflare", "Nginx"],
  "orgReadiness": "A",
  "orgLabel": "Prime target — verified org, strong repo traction, broad catalog, reachable contact.",
  "leadScore": "A",
  "hasContact": true
}
```

When an org's own website yields no email, the record still returns honestly — billed as an `org_lead` if it exposes a phone or social, or `hasContact: false` (not billed at all) if it exposes nothing.

### Real run sample

Verified live on Apify (2026-07-19). The three records below are copied verbatim from the actual run datasets across three distinct inputs — not fabricated or rounded:

- `{"searchQueries":["topic:developer-tools+stars:>500"],"maxPerQuery":10}` → 7 orgs incl. **ComposioHQ** (verified, 3 real socials, no email — billed as `org_lead` only) and **rtk-ai** (MX-verified `contact@rtk-ai.app` off its own site, `socials: {}` honestly empty — billed `org_lead` + `verified_email`).
- `{"orgs":["vercel","puppeteer","pulumi"]}` → 3 orgs incl. **pulumi** (verified, MX-verified `sales@pulumi.com` + `team@pulumi.com`).
- `{"searchQueries":["language:python+stars:>10000"],"verifiedOrgsOnly":true,"activeWithinDays":90,"maxPerQuery":8}` → 2 verified orgs, both `newlyActive: true`, incl. **TheAlgorithms** (MX-verified `hello@the-algorithms.com`, readiness A, 222,867 stars) and **Significant-Gravitas** (AutoGPT / agpt.co, 185,599 stars, `newestPush` today).

```json
[
  {
    "orgLogin": "TheAlgorithms",
    "orgName": "The Algorithms",
    "orgBlog": "https://the-algorithms.com/",
    "isVerified": true,
    "location": "India",
    "followers": 63118,
    "publicRepos": 44,
    "repoCount": 1,
    "totalStars": 222867,
    "newestPush": "2026-07-11T00:39:35+00:00",
    "topRepos": [{"name": "TheAlgorithms/Python", "stars": 222867, "pushedAt": "2026-07-11T00:39:35Z", "language": "Python", "repoUrl": "https://github.com/TheAlgorithms/Python"}],
    "newlyActive": true,
    "emails": ["hello@the-algorithms.com"],
    "emailVerified": true,
    "socials": {"twitter": "https://twitter.com/the_algorithms", "linkedin": "https://www.linkedin.com/company/thealgorithms"},
    "techStack": ["Cloudflare", "Nginx"],
    "orgReadiness": "A",
    "leadScore": "A",
    "hasContact": true
  },
  {
    "orgLogin": "ComposioHQ",
    "orgName": "Composio",
    "orgBlog": "https://composio.dev",
    "isVerified": true,
    "location": "United States of America",
    "followers": 2125,
    "publicRepos": 16,
    "repoCount": 1,
    "totalStars": 68056,
    "newestPush": "2026-05-22T03:17:49+00:00",
    "topRepos": [{"name": "ComposioHQ/awesome-claude-skills", "stars": 68056, "pushedAt": "2026-05-22T03:17:49Z", "language": "Python", "repoUrl": "https://github.com/ComposioHQ/awesome-claude-skills"}],
    "newlyActive": false,
    "emails": [],
    "emailVerified": false,
    "socials": {"twitter": "https://x.com/composio", "linkedin": "https://www.linkedin.com/company/composiohq/", "youtube": "https://www.youtube.com/@Composio"},
    "techStack": ["Cloudflare", "Google Analytics", "Google Tag Manager", "HubSpot", "Mailchimp", "React"],
    "orgReadiness": "B",
    "leadScore": "C",
    "hasContact": true
  },
  {
    "orgLogin": "rtk-ai",
    "orgName": "rtk-ai",
    "orgBlog": "https://www.rtk-ai.app",
    "isVerified": false,
    "location": "France",
    "followers": 657,
    "publicRepos": 7,
    "repoCount": 1,
    "totalStars": 71740,
    "newestPush": "2026-07-18T23:09:36+00:00",
    "topRepos": [{"name": "rtk-ai/rtk", "stars": 71740, "pushedAt": "2026-07-18T23:09:36Z", "language": "Rust", "description": "CLI proxy that reduces LLM token consumption by 60-90% on common dev commands. Single Rust binary, zero dependencies", "repoUrl": "https://github.com/rtk-ai/rtk"}],
    "newlyActive": false,
    "emails": ["contact@rtk-ai.app"],
    "emailVerified": true,
    "socials": {},
    "techStack": ["Google Analytics", "Google Tag Manager"],
    "orgReadiness": "C",
    "leadScore": "B",
    "hasContact": true
  }
]
```

The three records illustrate the full range: a **verified-email A-grade lead** (TheAlgorithms — MX-validated `hello@the-algorithms.com` off its own site, 222K stars, `newlyActive`), a **verified-org socials-only lead** (ComposioHQ — GitHub `is_verified`, three real company socials, no email exposed so billed `org_lead` only, **not** `verified_email`), and a **verified-email lead with no socials** (rtk-ai — `contact@rtk-ai.app` MX-validated, `socials: {}` honestly empty rather than a junk share-widget URL). Web-form placeholders such as `you@company.com` (seen on rtk-ai's site pre-cleaning) are dropped — never billed.

### Cost

Pay-per-event, charged only on a successful result:

| Event | Price | When |
|---|---|---|
| `org_lead` (primary) | **$0.008** | per org returning at least one real contact signal + their repo traction |
| `verified_email` | $0.003 | per org yielding an MX/DNS-validated email from its own site |
| `org_signal` | $0.001 | per org whose newest repo push is within the chosen window |
| `apify-actor-start` | $0.0001 | one-time run start |

Zero upstream compose cost (self-contained: keyless GitHub search/orgs APIs + the org's own public site). Primary event priced well above per-run compute — positive unit margin from day one.

### Performance & limits

- Pure keyless JSON (one `/search/repositories` per query + one `/orgs/{login}` per org, then one site fetch per org). No anti-bot, no proxy, no API key by default.
- **Honest keyless cap:** GitHub's core rate limit is 60 req/hr unauthenticated (search has its own 10/min limit) → batch ≤~50 orgs/run wall-clock with throttling. Supply your own `githubToken` to lift the core limit to 5,000/hr for larger batches.
- The actor retries 429/403-rate-limit responses with backoff, and silently drops orgs it cannot fetch (not billed).
- A `maxPerQuery=25` run typically resolves 25 repos → ~10–20 distinct Organization-typed owners after the User/owner gate → 5–15 sellable orgs after the blog-only filter, in well under a minute plus per-org site enrichment.

### Troubleshooting

- **No results / "no Organization-typed owners"** — the qualifiers resolved only to User/personal-account owners. Use org-level qualifiers (`topic:`, `language:` + `stars:>`) or pass explicit org logins via `orgs`.
- **"Org not found / not an org"** — an explicit login resolved to a User (404 on `/orgs`); skipped, not billed. Personal-account owners are deliberately not sold.
- **Fewer orgs than repos** — expected: repos roll up one-per-org (keyed by owner login), and User + no-blog orgs are dropped.
- **Rate-limited (empty search results)** — the keyless 60/hr core limit was hit mid-run. Lower `concurrency`, reduce the batch, or supply your own `githubToken`.
- **`newlyActive` not set** — the org's newest repo push is older than `activeWithinDays`; widen the window or leave it `0`.
- **An org you expected has no contact** — its `blog` site exposed no email/phone/social, so `hasContact: false` and it is **not billed** at all.

### Data sourcing & ToS

Discovery uses GitHub's public keyless `/search/repositories` + `/orgs/{login}` REST endpoints. Contact data is scraped **only** from the organization's OWN declared `blog` company website — the `/orgs` `email` public-profile address and GitHub user/commit/author emails are never mined for outreach (GitHub ToS §H). No login, no API key (optional user token only lifts rate limits), no residential proxy.

# Actor input Schema

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

GitHub search qualifiers passed directly to /search/repositories (e.g. 'topic:developer-tools+stars:>500', 'language:python+stars:>10000', 'topic:llm stars:>200'). Each query returns up to `maxPerQuery` repos; repos roll up to one lead per Organization-typed owner.

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

Explicit GitHub org logins (e.g. 'vercel') or org URLs (https://github.com/vercel). Resolved to one lead per org.

## `maxPerQuery` (type: `integer`):

Cap on repos returned per search query (1-100). Note the keyless GitHub core rate limit is 60 req/hr, so keep total orgs modest (<=~50/run); supply your own githubToken to lift to 5,000/hr.

## `organizationsOnly` (type: `boolean`):

Keep only Organization-typed owners (User/personal-account owners are dropped — the ToS-clean gate; GitHub user emails are never mined). Default true.

## `blogOnly` (type: `boolean`):

Keep only orgs that declared their OWN `blog` company website (the clean acquisition hop). Orgs without one are honestly dropped (not billed) — the data-driven equivalent of Docker's bare-official-image drop. Default true.

## `verifiedOrgsOnly` (type: `boolean`):

Keep only orgs carrying the GitHub `is_verified` badge (the org verified a domain — a genuine trust signal, live-verified 2026-07-19).

## `activeWithinDays` (type: `integer`):

Flag orgs whose newest repo `pushed_at` falls within the trailing N days as `newlyActive` (rolling window, 0 = disabled). `pushed_at` is the newest repo activity, so this is an `actively maintained within the window` signal, not a `created within the window` claim.

## `verifyEmails` (type: `boolean`):

Validate the best contact email's domain against live MX/DNS records.

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

Your own GitHub Personal Access Token (classic or fine-grained, public-read scope). Optional. Empty = keyless (60 req/hr core limit). Supplying your token lifts the core limit to 5,000/hr for larger batches. This is YOUR token, entered by you — never stored by us.

## `concurrency` (type: `integer`):

Orgs/repos processed in parallel (1-8). Lower this if you hit keyless rate limits.

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

Optional. Only needed if you hit IP rate limits; the Actor works without a proxy (the keyless GitHub APIs).

## Actor input object example

```json
{
  "searchQueries": [
    "topic:developer-tools+stars:>500",
    "language:rust+stars:>1000"
  ],
  "orgs": [
    "vercel",
    "https://github.com/puppeteer"
  ],
  "maxPerQuery": 25,
  "organizationsOnly": true,
  "blogOnly": true,
  "verifiedOrgsOnly": false,
  "activeWithinDays": 0,
  "verifyEmails": true,
  "githubToken": "",
  "concurrency": 3,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `results` (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 = {
    "searchQueries": [
        "topic:developer-tools+stars:>500"
    ],
    "orgs": [],
    "githubToken": "",
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("ayeeyee/github-org-devtool-lead-extractor").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 = {
    "searchQueries": ["topic:developer-tools+stars:>500"],
    "orgs": [],
    "githubToken": "",
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("ayeeyee/github-org-devtool-lead-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "topic:developer-tools+stars:>500"
  ],
  "orgs": [],
  "githubToken": "",
  "proxyConfiguration": {}
}' |
apify call ayeeyee/github-org-devtool-lead-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ayeeyee/github-org-devtool-lead-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/8ges75nxnRq0epVyz/builds/DCsLDDfJ6LHsaa9Yz/openapi.json