# GitHub Tech Adoption Lead Finder (`coolinbex/github-tech-adoption-lead-finder`) Actor

Finds companies actually using a technology based on verifiable public GitHub evidence.

- **URL**: https://apify.com/coolinbex/github-tech-adoption-lead-finder.md
- **Developed by:** [coolinbex](https://apify.com/coolinbex) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 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.

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

## GitHub Tech Adoption Lead Finder

Find companies actually using a technology based on verifiable public GitHub evidence.

This Apify Actor helps B2B sales, partnerships, developer relations, and GTM teams identify organizations whose public GitHub repositories show real adoption of a framework, SDK, API, database, package, or developer tool.

It is not a generic GitHub repository scraper. A repository description or README mention is not enough for a high-confidence lead. The Actor looks for concrete signals such as dependency manifests, SDK imports, configuration keys, technology-specific files, and initialization code, then deduplicates results into unique company leads.

### Example Use Cases

- Find companies using Supabase, Stripe, Prisma, Sentry, Clerk, Auth0, LangChain, or Pinecone.
- Build account lists from public developer adoption signals.
- Prioritize leads with recent development activity.
- Enrich GitHub organizations with public website, contact, careers, and metadata signals.
- Export clean CSV-ready company leads instead of many duplicate repository rows.

### Input

```json
{
  "technology": "Supabase",
  "packageNames": ["@supabase/supabase-js"],
  "technologyAliases": ["supabase"],
  "maxResults": 100,
  "minimumRecentActivityDays": 365,
  "companyOnly": true,
  "includeForks": false,
  "minimumConfidence": 70
}
```

#### Fields

- `technology` required: Technology, framework, SDK, package, API, database, or developer tool.
- `packageNames`: Optional exact package names to treat as strong dependency evidence.
- `technologyAliases`: Optional aliases and keywords used for discovery and matching.
- `languages`: Optional GitHub language filters.
- `maxResults`: Maximum number of unique company leads to output. A billable result should represent one unique company lead.
- `maxRepositoriesToInspect`: Safety cap for repository verification work.
- `minimumStars`: Optional repository star threshold. Stars are not the primary lead quality signal.
- `minimumRecentActivityDays`: Recent activity window. Set `0` to disable.
- `includePersonalRepositories`: Include user-owned repositories when they appear business-related.
- `includeForks`: Include forked repositories.
- `companyOnly`: Exclude owners that cannot be tied to a company or organization.
- `minimumConfidence`: Minimum deterministic technology confidence score.
- `githubToken`: Optional GitHub token. Prefer Apify secrets or the `GITHUB_TOKEN` environment variable.
- `concurrency`: Number of repositories to inspect concurrently.
- `includeWebsiteEnrichment`: Fetch a small amount of public website metadata when available.

### Technology Detection

The Actor includes a mapping system for common technologies so users do not need to know every package name. Current built-in mappings include:

- Supabase: `@supabase/supabase-js`, Python `supabase`, Supabase config keys.
- Stripe: `stripe`, `@stripe/stripe-js`, Python/Ruby/PHP Stripe packages, Stripe config keys.
- Prisma: `@prisma/client`, `prisma`, `prisma/schema.prisma`.
- Sentry: `@sentry/*`, `sentry-sdk`, `github.com/getsentry/sentry-go`, Sentry config keys.
- Auth0, Clerk, LangChain, and Pinecone.

You can add technologies by extending [src/detection/technologies.ts](src/detection/technologies.ts).

### Evidence And Confidence

Every output lead includes actual evidence from a public repository file.

Strong evidence:

- Direct dependency in a manifest.
- SDK import statement.
- SDK initialization.

Medium evidence:

- Technology-specific configuration.
- Technology-specific files or deployment setup.

Weak evidence:

- README or documentation mention.

Weak evidence alone normally stays below the default confidence threshold. Scores are deterministic and include `confidenceReasons`.

### Output

Each dataset item represents one unique company lead by default.

```json
{
  "technology": "Supabase",
  "companyName": "Example Inc",
  "githubOrganization": "example",
  "githubOrganizationUrl": "https://github.com/example",
  "companyWebsite": "https://example.com",
  "location": "New York, NY",
  "publicEmail": "hello@example.com",
  "repository": "example/product",
  "repositoryUrl": "https://github.com/example/product",
  "repositoryDescription": "Production application",
  "repositoryStars": 42,
  "repositoryLastUpdated": "2026-09-01T12:00:00Z",
  "evidenceType": "package dependency",
  "evidenceFile": "package.json",
  "evidenceValue": "@supabase/supabase-js",
  "technologyConfidence": 95,
  "confidenceReasons": [
    "Direct dependency found in package.json",
    "Repository updated within last 30 days"
  ],
  "repositoriesUsingTechnology": 3,
  "leadQualityScore": 91,
  "companyVerified": true,
  "contactPage": "https://example.com/contact",
  "careersPage": "https://example.com/careers",
  "discoveredAt": "2026-09-11T08:00:00.000Z"
}
```

The full item also includes `evidenceRepositories`, a compact list of the strongest supporting repositories for that company.

### GitHub API Behavior

For best results, provide a GitHub token with read access to public repositories. The Actor does not automate GitHub login and does not access private repositories.

With a token:

- Uses GitHub REST code search to discover file-level evidence.
- Applies retry and rate-limit handling.
- Inspects supporting files through the official contents API.

Without a token:

- Code search is skipped.
- The Actor falls back to repository search and common manifest/config file inspection.
- GitHub API rate limits are much lower.

### Website Enrichment

When `includeWebsiteEnrichment` is enabled, the Actor fetches the public website listed on the GitHub owner profile and extracts only basic, explicitly public information:

- Page title and meta description.
- Contact and careers links.
- Publicly displayed email addresses.
- LinkedIn company link if present.

Website enrichment uses short timeouts and does not crawl hundreds of pages. Website errors never fail the whole run.

### Filtering

The Actor avoids common false positives:

- Tutorial, demo, starter, example, coursework, documentation, and awesome-list repositories.
- Forks when `includeForks` is disabled.
- Template and archived repositories.
- Repositories owned by the technology vendor.
- Description-only or README-only mentions as strong evidence.

### Limitations

- Public GitHub data is incomplete and may not reflect private production systems.
- GitHub code search quality and rate limits depend heavily on token availability.
- Company identification is conservative. The Actor does not guess private emails or invent company data.
- Personal repositories are excluded by default unless business ownership is apparent.
- Website enrichment only uses small public-page fetches.

### Development

```bash
npm install
npm run build
npm test
npm run lint
npm start
```

Local Actor input is read from Apify local storage. On the Apify platform, use the input UI generated from [.actor/input\_schema.json](.actor/input_schema.json).

### Store Readiness Notes

This Actor is structured so pay-per-result pricing can be added later with one result equal to one unique company lead, not every repository or file inspected.

Before publishing, run live checks with a GitHub token for at least Supabase, Stripe, and Prisma, inspect the dataset manually, and verify that each result contains real file-level evidence and clean company-level deduplication.

# Actor input Schema

## `technology` (type: `string`):

Technology, framework, SDK, database, API, package, or developer tool to find adoption evidence for.

## `packageNames` (type: `array`):

Optional exact package names to use as strong dependency evidence.

## `technologyAliases` (type: `array`):

Optional aliases, import names, or keywords associated with the technology.

## `languages` (type: `array`):

Optional GitHub language filters, for example JavaScript, TypeScript, Python, Go.

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

Maximum number of unique company leads to output.

## `maxRepositoriesToInspect` (type: `integer`):

Safety cap for repository verification work.

## `minimumStars` (type: `integer`):

Ignore repositories with fewer stars. Stars are not used as the primary lead quality signal.

## `minimumRecentActivityDays` (type: `integer`):

Only include repositories updated within this many days. Set 0 to disable.

## `includePersonalRepositories` (type: `boolean`):

Include user-owned repositories when they appear to represent a business.

## `includeForks` (type: `boolean`):

Include forked repositories.

## `companyOnly` (type: `boolean`):

Exclude repositories that cannot be reasonably tied to an organization or business.

## `minimumConfidence` (type: `integer`):

Minimum deterministic confidence score required for a repository to count as adoption evidence.

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

Optional GitHub token. Prefer Apify secrets or the GITHUB\_TOKEN environment variable.

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

Number of repositories to inspect concurrently.

## `includeWebsiteEnrichment` (type: `boolean`):

Fetch a small number of public website pages to enrich company metadata.

## Actor input object example

```json
{
  "technology": "Supabase",
  "packageNames": [
    "@supabase/supabase-js"
  ],
  "technologyAliases": [
    "supabase"
  ],
  "languages": [
    "TypeScript"
  ],
  "maxResults": 100,
  "maxRepositoriesToInspect": 250,
  "minimumStars": 0,
  "minimumRecentActivityDays": 365,
  "includePersonalRepositories": false,
  "includeForks": false,
  "companyOnly": true,
  "minimumConfidence": 70,
  "githubToken": "github_pat_...",
  "concurrency": 4,
  "includeWebsiteEnrichment": false
}
```

# Actor output Schema

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

Default dataset containing one item per unique company lead.

# 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 = {
    "technology": "Supabase"
};

// Run the Actor and wait for it to finish
const run = await client.actor("coolinbex/github-tech-adoption-lead-finder").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 = { "technology": "Supabase" }

# Run the Actor and wait for it to finish
run = client.actor("coolinbex/github-tech-adoption-lead-finder").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 '{
  "technology": "Supabase"
}' |
apify call coolinbex/github-tech-adoption-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,coolinbex/github-tech-adoption-lead-finder"
        }
    }
}

```

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/3erL3kXS3rzNJGBZ3/builds/VJYqPGyPvUjsKl2cv/openapi.json