# GitHub Organization Signal Scanner - Domain to Org (`mambalabs/github-organization-signal-scanner`) Actor

Resolves a company domain to its GitHub organization and returns repository count, followers, top languages, total stars, recent push activity and whether it ships a public SDK. One flat row per company, Clay ready. Add your own GitHub token to run at scale.

- **URL**: https://apify.com/mambalabs/github-organization-signal-scanner.md
- **Developed by:** [Mamba Labs](https://apify.com/mambalabs) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 company checkeds

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?

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

### 🔎 What can GitHub Organization Signal Scanner do?

Give it a company domain. It finds that company's GitHub organization and returns repository count, followers, top languages, total stars, the most recent push, how many repositories are actively worked on and whether the company ships a public SDK. One flat row per company.

It uses GitHub's own documented REST API. No scraping, no browser, no login required.

| 📦 What you get | ⚙️ Features and integrations |
|---|---|
| 🐙 **GitHub organization** resolved from a company domain<br>📦 **Repo count, stars, followers and top languages**<br>⚡ **Recent push activity** and repos active in your window<br>🧾 **32 flat fields**, `snake_case`, one row per company | 🔑 **Runs keyless**, bring your own GitHub token for scale<br>🎯 **Candidate rejection recorded** in `github_rejected_candidate`<br>🧰 **Public SDK detection**, a direct developer tooling signal<br>⬇️ **Export** to JSON, CSV, Excel, HTML or XML |

Bought by developer tooling and infrastructure sellers, technical recruiters, and investors screening for engineering activity that a headcount number does not show.

> 🚫 **This is not a code scanner or a security audit.** It reads organization and repository metadata. It does not clone repositories, read source, scan for secrets or assess code quality.

### 💡 Why use GitHub Organization Signal Scanner?

**It starts from a domain.** Every GitHub tool on the Apify Store starts from an org login or a repository URL, which is the thing you do not have when you are holding a list of company domains. Resolving the two is the actual work and it is what this does.

**The activity signals are the buying signal.** `most_recent_push_at` and `active_repos_90d` separate a company with an engineering team shipping code from a company with a GitHub organization somebody created in 2019. A repository count alone cannot tell those apart.

**`has_public_sdk` is a qualification field.** A company publishing an SDK, a client library or a CLI has an integration surface and usually a developer audience, which changes both who you sell to and what you say.

**Rate limiting is reported, never rounded to zero.** When GitHub throttles a request the row says `not_extractable`. It never returns a zero, because a zero is a number and you would filter on it.

#### 🧭 Four routes to the organization, strongest first

1. **You supply it.** Put a login in `github_org` and the actor skips discovery and spends fewer of your rate limited requests.
2. **The company homepage.** Its own links, read directly with no proxy. A company linking to its own GitHub organization is the strongest evidence available without a login.
3. **`github.com/{domain stem}`**, a guess, which must then be corroborated.
4. **A web search**, last, also corroborated.

Routes 3 and 4 do not ship an answer on their own. The organization's own `blog` field has to point back at your domain, or its name has to match the company name. `github_corroborated_by` records which one did it.

### 📋 What data can GitHub Organization Signal Scanner extract?

Every row carries **32 flat fields**. These are the ones a buyer
actually filters and sorts on.

| Field | Type | Meaning |
|---|---|---|
| `degraded` | boolean | True when this row could not be produced normally, for example the company site was unreachable and no discovery could run. A degraded row is never charged. |
| `degradation_reason` | string | null | Why the row is degraded, in plain words. Null on a normal row. |
| `company_domain` | string | null | The company domain this row is about, normalized. Null when only a handle or a name was supplied. This is the join key across the whole Mamba Labs fleet. |
| `company_name` | string | null | The company name as supplied or derived. Improves search accuracy and is what the identity gate matches against. |
| `github_org` | string | null | The organization login, for example "stripe". Null when no organization could be found and vouched for. |
| `github_url` | string | null | Canonical organization URL. |
| `github_discovery` | string | null | How the organization was found: input\_handle (you supplied it), homepage\_link (the company links to it from its own site, the strongest evidence available without a login), search, or pattern\_guess. Anything below homepage\_link had to pass a corroboration check before it shipped, and you can filter on this if a wrong match would be expensive. |
| `github_corroborated_by` | string | null | What independently confirmed a weakly discovered organization: profile\_link means the organization blog field points back at your domain, display\_name means its name matches the company name. Null on the strong routes, which need no corroboration. This is the field that stops a guessed login shipping as an answer. |
| `github_rejected_candidate` | string | null | When fetch\_status is identity\_mismatch, the organization URL that was found and DROPPED, with the reason. It is deliberately not in github\_url: a rejected organization in the answer column is a wrong answer that anyone filtering on "has a GitHub URL" would pick up. Measured example: github.com/notion is a real organization named Trove and is not Notion. |
| `github_account_type` | string | null | Organization or User. A company whose code lives under a founder personal account returns User with fetch\_status identity\_mismatch, which is a real and useful finding rather than a miss. |
| `public_repos` | integer | null | How many public repositories the organization has, as GitHub reports it. Zero is a real answer and means an organization that exists and publishes nothing. |
| `followers` | integer | null | Organization follower count. A reach proxy, not a measurement of engineering size. |
| `org_created_at` | string | null | When the organization was created on GitHub, ISO 8601. Useful for telling an established engineering presence from one opened last quarter. |
| `org_location` | string | null | Location as the organization publishes it, free text. |
| `org_blog` | string | null | The URL the organization publishes as its own site. This is also the field the identity check uses: an organization that points back at your domain is the company organization, and that is an independent signal rather than a restatement of how it was found. |
| `org_description` | string | null | The organization description text, which is empty on plenty of real organizations. |
| `top_languages` | string | null | Up to five primary languages across the sampled repositories, most common first, comma separated. Forks and archived repositories are excluded: a company that forked three hundred repositories is not a company writing those languages. |
| `total_stars` | integer | null | Stars summed across the sampled non fork repositories. When repos\_complete is false this is a FLOOR and not a total, because only part of the organization was read. |
| `most_starred_repo` | string | null | Name of the most starred non fork repository in the sample. Null when every sampled repository has zero stars, which is a real answer. |
| `most_starred_repo_stars` | integer | null | Star count of that repository. |
| `most_recent_push_at` | string | null | The most recent push across the sampled non fork repositories, ISO 8601. This is the single best liveness signal on the row: an organization whose last push was three years ago is a very different prospect from one that pushed this morning. |
| `active_repos_90d` | integer | null | How many sampled non fork repositories were pushed inside the active window, which is 90 days unless you changed it. Zero is a real answer and means a public presence that is not currently being worked on. |
| `contributor_count_estimate` | integer | null | An ESTIMATE of the public engineering surface: the number of contributors to the organization most starred public repository, read from GitHub own pagination. It is a floor for the organization and it is NOT a headcount. Null unless you switched includeContributorEstimate on. |
| `contributor_estimate_basis` | string | null | Which repository the contributor estimate was measured on, so the number is never a figure with no provenance. |
| `has_public_sdk` | boolean | null | True when a sampled repository looks like a shipped SDK, client library, connector or CLI, by repository name or by GitHub topic. FALSE means we read the repositories and found none, which is a real finding. NULL means the repositories were never read. |
| `repos_sampled` | integer | null | How many repositories were actually read, including forks and archived ones. Every derived field above is computed over this sample and no larger set. |
| `repos_complete` | boolean | null | True when every public repository was read. FALSE means the page budget was reached first, so total\_stars is a floor and the language ranking is drawn from the most recently pushed repositories rather than from all of them. |
| `repos_excluded` | string | null | How many sampled repositories were left out of the derivations and why, as counts: forks and archived. A check that cannot say what it dropped is not a passing check, so this ships on the row. |
| `rate_limit_remaining` | integer | null | GitHub own count of requests you have left this hour, as of this row. Without a token the ceiling is 60. Watch this column on a batch: when it reaches zero the remaining rows come back not\_extractable, which is honest and is still not data. |
| `coverage` | number | null | How much of what this actor can return actually came back on this row, from 0 to 1. Computed over this actor value fields only, never over the identity or status columns. Null on a degraded row, where nothing was attempted. This is a reporting field: nothing is dropped for low coverage and no event fires on it. |
| `fetch_status` | string | ok, not\_found, not\_extractable, blocked, identity\_mismatch, auth\_failed or skipped. Read this before reading any value on the row. not\_found means we looked and there is nothing there; blocked and not\_extractable mean we could not look, and they must never be read as an absence. |
| `run_date` | string | ISO 8601 timestamp of this run. Social counts move, so a row without a date is a number with no shelf life. |

> ⚠️ **How to read these values.** `repos_complete: false` means the page budget was reached before the repositories ran out, so `total_stars` is a floor rather than a total. `repos_excluded` says how many forks and archived repositories were left out of the derivations.

### 🛠️ How to find a company GitHub organization from a domain

1. Put a company domain in `company_domain`.
2. Create a free GitHub token at github.com/settings/tokens, no scopes needed, and put it in `githubToken`. Without one you get 60 requests an hour, which is fine for a demo and not enough for a list.
3. Leave `includeRepoDetail` on unless you only want the organization record.
4. For a list, pass an array of objects with the same fields.

#### 🧪 Using it in Clay

Add an **Enrichment > Apify** column, pick this actor, and map `company_domain` to your domain column. Every field arrives flat and snake\_case.

Put your GitHub token in the actor input once and it applies to the whole column. Gate the column on your ICP filter first: there is no point resolving a GitHub organization for a company you will not contact, and every run spends a request from your hourly budget.

### 💵 How much does it cost?

Pay per event. You are charged for output, never for input.

| Event | Fires when | Price |
|---|---|---|
| `company-checked` | Once per company for which the organization discovery cascade completed and a non degraded row was produced, whether or not anything was found. A not\_found row fires this event, because looking and finding nothing is a real answer and it is the work you asked for. A degraded row, where the lookup could not run at all, fires nothing. | $0.0030 |
| `org-resolved` | Once per company whose candidate GitHub organization passed the identity gate and was read from the API. Fires on the validation and retrieval work, not on a populated repository set. A candidate dropped as somebody else organization does not charge: the work was done and the honest answer is that there is no organization we can vouch for. | $0.0025 |
| `repo-signals-extracted` | Once per company where at least one page of repositories was read and the language, star and activity signals were derived from it. Does not fire when includeRepoDetail is off, and does not fire when the repository request was rate limited, because in both cases no derivation happened. | $0.0030 |

> 💳 **What you are billed for.** `repo-signals-extracted` fires only when repositories were actually read and derived from. Switching `includeRepoDetail` off means it never fires.
>
> A rate limited repository request charges nothing for the derivation that did not happen, and a company with no organization charges only `company-checked`.

**What the same coverage costs bought a la carte:** No Apify Store actor takes a company DOMAIN and returns a GitHub organization. The Store carries repository and issue scrapers that all require a repository URL or an org login, which is the thing a buyer holding a CRM export does not have. The discovery step is the whole product and the API half is deliberately priced near cost because GitHub gives it away.

### ⌨️ Input

| Field | Type | Required | Meaning |
|---|---|---|---|
| `company_domain` | string | no | Bare company domain, for example stripe.com. This is the only required input and it is the join key for every other actor in the fleet. |
| `company_name` | string | no | Optional but strongly recommended. It is what the identity gate checks a discovered record against, so supplying it is the single cheapest way to reduce wrong matches. |
| `github_org` | string | no | Optional. If you already know the organization login, for example "stripe", put it here and the actor skips discovery entirely and goes straight to the API, which is faster and spends fewer of your rate limited requests. |
| `includeRepoDetail` | string | no | When "true" (default) the organization repositories are read and the language, star, activity and SDK signals are derived from them. Set "false" to return the organization record only, which is one request instead of several and is much friendlier to the unauthenticated rate limit. Sent as a string for Clay compatibility. |
| `includeContributorEstimate` | string | no | When "true" the actor spends one extra request to read the contributor count of the organization most starred repository, as a floor on the size of its public engineering surface. Default "false", because one extra request per company is real money against a 60 per hour unauthenticated budget. Sent as a string for Clay compatibility. |
| `activeWindowDays` | string | no | How recently a repository must have been pushed to count as active. 90 days by default. This changes what "active" means on the row, so pick the window your own definition of an engaged engineering team uses. Sent as a string for Clay compatibility. |
| `repoPageBudget` | string | no | How many pages of 100 repositories to read for a large organization. This is a cost and completeness dial, not a change of answer: the row always reports how many repositories were actually sampled and whether the sample is complete. Sent as a string for Clay compatibility. |
| `githubToken` | string | no | YOUR OWN GitHub personal access token, free to create at github.com/settings/tokens with no scopes at all for public data. OPTIONAL: without it the actor runs at GitHub 60 requests per hour, which is enough for a handful of companies and not enough for a list. With it the limit is 5,000 per hour. It is marked secret, so the value never renders on this page. |
| `skipCache` | string | no | When "false" (default) a successful lookup is cached for seven days and reused, which costs you nothing on a repeated run. Set "true" to force a fresh fetch. Sent as a string for Clay compatibility. |

```json
{
  "company_domain": "stripe.com",
  "company_name": "Stripe",
  "includeRepoDetail": "true",
  "activeWindowDays": "90"
}
```

### 📤 Output

Exports to **JSON, CSV, Excel, HTML or XML**. One flat, snake\_case row per
company. No nested objects, so it drops straight into Clay, a spreadsheet or a
warehouse table without a flattening step.

```json
{
  "degraded": false,
  "degradation_reason": null,
  "company_domain": "stripe.com",
  "company_name": "Stripe",
  "github_org": "stripe",
  "github_url": "https://github.com/stripe",
  "github_discovery": "homepage_link",
  "github_corroborated_by": null,
  "github_rejected_candidate": null,
  "github_account_type": "Organization",
  "public_repos": 98,
  "followers": 3469,
  "org_created_at": "2011-06-17T15:42:37Z",
  "org_location": "San Francisco, CA",
  "org_blog": "https://stripe.dev",
  "org_description": null,
  "top_languages": "TypeScript, Go, Ruby, JavaScript, HTML",
  "total_stars": 42821,
  "most_starred_repo": "stripe-node",
  "most_starred_repo_stars": 4485,
  "most_recent_push_at": "2026-08-22T18:33:15.000Z",
  "active_repos_90d": 56,
  "contributor_count_estimate": null,
  "contributor_estimate_basis": null,
  "has_public_sdk": true,
  "repos_sampled": 98,
  "repos_complete": true,
  "repos_excluded": "forks=6, archived=5",
  "rate_limit_remaining": 57,
  "coverage": 1,
  "fetch_status": "ok",
  "run_date": "2026-08-22T19:23:50.177Z"
}
```

#### false versus null, and why the difference matters

`false` means we looked and the answer is no. `null` means we could not look,
or the platform withheld it. They are never interchangeable in this output. If
you filter for companies with no presence on this platform, filter on `false`,
because `null` rows are unknown rather than absent and including them will
overstate your list.

### 💡 Tips

- **Bring a token.** 60 requests an hour is the single biggest constraint on this actor and a free token removes it entirely.
- **Sort a list by `most_recent_push_at`.** It is the fastest way to separate live engineering organizations from dormant ones.
- **`has_public_sdk: false` is a real answer**, not a missing one. Null is the missing one, and it means the repositories were never read.
- **Watch `rate_limit_remaining` on a batch.** When it hits zero the rest of the batch comes back `not_extractable`, which is honest and is still not data.
- **Set `includeRepoDetail` to false** when you only need presence and follower counts. It is one request per company instead of several.

### ⚠️ Known limits

- **Unauthenticated runs are limited to 60 requests per hour by GitHub, not by us.** A batch larger than a few dozen companies needs your own token.
- **Private repositories are invisible**, which means a company doing all its work in private looks quiet here. Absence of public activity is not absence of engineering.
- **Derived fields are computed over the sample**, not over every repository, whenever `repos_complete` is false.
- **`contributor_count_estimate` is one repository's contributor count**, named in `contributor_estimate_basis`. It is a floor on the public engineering surface and it is not a headcount.
- **A company whose code lives under a personal account** returns `fetch_status: identity_mismatch` with the account URL. That is deliberate: it is a finding, and it is not an organization.

### ❓ FAQ

**Do I need a GitHub token?**
Not to try it. Yes to run a list. Without one GitHub allows 60 requests an hour across everything the actor does.

**Why is `public_repos` null instead of zero?**
Because the request was rate limited or refused. Zero means the organization genuinely publishes nothing; null means we could not look. The two are never conflated.

**What if the company has no GitHub presence?**
You get `fetch_status: not_found` with the identity columns populated. That is a real answer and it is charged as a check, not as a resolution.

**Does it read private repositories with my token?**
No. Only public data is requested, which is why a token with no scopes at all is enough.

**Why does the row say `identity_mismatch`?**
The login exists and is a personal user account rather than an organization. Common at small companies, and worth knowing.

### 🧩 Want other GTM data?

Mamba Labs builds a fleet of GTM enrichment actors that share one flat,
Clay-ready output convention, so their rows join on `company_domain` with no
cleaning step:

| | |
|---|---|
| 🕵️ [Agent Accessibility Auditor](https://apify.com/mambalabs/agent-accessibility-auditor) | 🤖 [AI Tooling Detector](https://apify.com/mambalabs/ai-tooling-detector) |
| 📡 [B2B Buying Signals Aggregator](https://apify.com/mambalabs/b2b-buying-signals-hiring-tech-stack-intent-for-clay) | 🚀 [Prospect Engine](https://apify.com/mambalabs/b2b-prospect-engine) |
| 📝 [Publishing Frequency Tracker](https://apify.com/mambalabs/blog-publishing-frequency) | ⏩ [Sequencer Lead Push](https://apify.com/mambalabs/clay-to-instantly-smartlead-push) |
| 🔄 [Company Change-Event Feed](https://apify.com/mambalabs/company-change-event-feed) | 🧭 [Company Discovery List Builder](https://apify.com/mambalabs/company-discovery-list-builder) |
| 🏢 [Company Firmographic Enricher](https://apify.com/mambalabs/company-firmographic-enricher) | 🪪 [Company Identity Resolver](https://apify.com/mambalabs/company-identity-resolver) |
| 🌐 [Company Social Presence Mapper](https://apify.com/mambalabs/company-social-presence-mapper) | 🏷️ [Contact Classifier](https://apify.com/mambalabs/contact-classifier) |
| 📬 [Domain Deliverability Checker](https://apify.com/mambalabs/domain-deliverability-checker) | 🔗 [Domain to LinkedIn URL Resolver](https://apify.com/mambalabs/domain-to-linkedin-url-resolver) |
| ✉️ [Work Email Waterfall Finder](https://apify.com/mambalabs/email-waterfall-orchestrator) | 🎪 [Event Presence Index](https://apify.com/mambalabs/event-presence-index) |
| 💰 [Funding and Press Signal Scanner](https://apify.com/mambalabs/funding-press-signal-scanner) | 🧑‍💼 [GTM Hiring Signal Scraper](https://apify.com/mambalabs/gtm-hiring-signal-scraper) |
| 📋 [Job Posting Monitor](https://apify.com/mambalabs/gtm-job-discovery) | 🧱 [Tech Stack Detector](https://apify.com/mambalabs/gtm-tech-stack-signal-scraper) |
| 🎯 [ICP Fit Scorer](https://apify.com/mambalabs/icp-account-lead-scoring-fit-scorer-0-100-for-clay) | 🔑 [Job Board Keyword Scanner](https://apify.com/mambalabs/job-board-keyword-signal-scanner) |
| ⚖️ [Legal Entity Resolver](https://apify.com/mambalabs/legal-entity-resolver) | 💼 [LinkedIn Company Page Mapper](https://apify.com/mambalabs/linkedin-company-presence-mapper) |
| 💬 [LinkedIn Post Tracker and Comment Capture](https://apify.com/mambalabs/linkedin-post-engager-capture) | 📸 [Instagram and Facebook Brand Mapper](https://apify.com/mambalabs/meta-brand-presence-mapper) |
| 📮 [Outbound Stack Detector](https://apify.com/mambalabs/outbound-infrastructure-fingerprint) | 📄 [Page Finder and Extractor](https://apify.com/mambalabs/page-finder-extractor) |
| 👤 [People Finder and Email Verifier](https://apify.com/mambalabs/people-finder) | 📌 [Pinterest Brand Presence Mapper](https://apify.com/mambalabs/pinterest-brand-presence-mapper) |
| 🏛️ [Government Contract Award Monitor](https://apify.com/mambalabs/public-award-monitor) | 📅 [Public Company Reporting Window Finder](https://apify.com/mambalabs/public-company-reporting-window-finder) |
| 👥 [Team Page People Extractor](https://apify.com/mambalabs/team-page-people-extractor) | 🎵 [TikTok Brand Presence Mapper](https://apify.com/mambalabs/tiktok-brand-presence-mapper) |
| 🏅 [Workplace Program Detector](https://apify.com/mambalabs/workplace-program-detector) | ▶️ [YouTube Channel Stats Extractor](https://apify.com/mambalabs/youtube-channel-transcript-extractor) |

> Every actor in the suite takes a domain or a company and returns one flat row,
> so they stack in the same Clay table without reshaping anything.

> 🛠️ **Need something custom built for you or your team?** Tell us what you are
> trying to find and we will build it. [Talk to Mamba Labs](https://mambabuilt.com/contact).

### 🆘 Support

Issues, field requests and bug reports: open an issue on the actor's Issues tab.
Mamba Labs reads every one.

> ℹ️ **Sourcing and legal.** Every field comes from GitHub's public REST API, read within its documented rate limits, which `rate_limit_remaining` reports on every row. Only organization level and repository level metadata is returned. If you supply your own token, that call is governed by your agreement with GitHub.

Built by [Mamba Labs](https://apify.com/mambalabs).

# Actor input Schema

## `company_domain` (type: `string`):

Bare company domain, for example stripe.com. This is the only required input and it is the join key for every other actor in the fleet.

## `company_name` (type: `string`):

Optional but strongly recommended. It is what the identity gate checks a discovered record against, so supplying it is the single cheapest way to reduce wrong matches.

## `github_org` (type: `string`):

Optional. If you already know the organization login, for example "stripe", put it here and the actor skips discovery entirely and goes straight to the API, which is faster and spends fewer of your rate limited requests.

## `includeRepoDetail` (type: `string`):

When "true" (default) the organization repositories are read and the language, star, activity and SDK signals are derived from them. Set "false" to return the organization record only, which is one request instead of several and is much friendlier to the unauthenticated rate limit. Sent as a string for Clay compatibility.

## `includeContributorEstimate` (type: `string`):

When "true" the actor spends one extra request to read the contributor count of the organization most starred repository, as a floor on the size of its public engineering surface. Default "false", because one extra request per company is real money against a 60 per hour unauthenticated budget. Sent as a string for Clay compatibility.

## `activeWindowDays` (type: `string`):

How recently a repository must have been pushed to count as active. 90 days by default. This changes what "active" means on the row, so pick the window your own definition of an engaged engineering team uses. Sent as a string for Clay compatibility.

## `repoPageBudget` (type: `string`):

How many pages of 100 repositories to read for a large organization. This is a cost and completeness dial, not a change of answer: the row always reports how many repositories were actually sampled and whether the sample is complete. Sent as a string for Clay compatibility.

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

YOUR OWN GitHub personal access token, free to create at github.com/settings/tokens with no scopes at all for public data. OPTIONAL: without it the actor runs at GitHub 60 requests per hour, which is enough for a handful of companies and not enough for a list. With it the limit is 5,000 per hour. It is marked secret, so the value never renders on this page.

## `skipCache` (type: `string`):

When "false" (default) a successful lookup is cached for seven days and reused, which costs you nothing on a repeated run. Set "true" to force a fresh fetch. Sent as a string for Clay compatibility.

## `source_tag` (type: `string`):

Internal attribution tag set by Mamba Labs on published task examples. Not required, and nothing depends on it. Leave it empty.

## Actor input object example

```json
{
  "company_domain": "stripe.com",
  "company_name": "Stripe",
  "includeRepoDetail": "true",
  "includeContributorEstimate": "false",
  "activeWindowDays": "90",
  "repoPageBudget": "3",
  "skipCache": "false"
}
```

# Actor output Schema

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

Dataset of one flat row per company, with per platform status so a blocked fetch never reads as a zero.

# 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 = {
    "company_domain": "stripe.com",
    "company_name": "Stripe",
    "github_org": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/github-organization-signal-scanner").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 = {
    "company_domain": "stripe.com",
    "company_name": "Stripe",
    "github_org": "",
}

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/github-organization-signal-scanner").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 '{
  "company_domain": "stripe.com",
  "company_name": "Stripe",
  "github_org": ""
}' |
apify call mambalabs/github-organization-signal-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mambalabs/github-organization-signal-scanner"
        }
    }
}

```

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/ahF8RRpv5mzPao5CN/builds/HVrBpDUZVhMZdtd9q/openapi.json