# AI Tool Stack Detector (`ianymu/ai-tool-stack-detector`) Actor

Detect which AI dev tools (Cursor, Claude Code, Copilot, Windsurf, Cody, Codeium, Aider, Continue, Tabnine, Cline) any company's engineering team uses. Aggregates public signals: careers pages, engineering blog, GitHub org repo markers. Returns confidence-scored profile with evidence.

- **URL**: https://apify.com/ianymu/ai-tool-stack-detector.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## AI Tool Stack Detector

> **Tell us a company name — we'll tell you which AI dev tools their engineers actually use. Cursor? Claude Code? Copilot? Windsurf? Pulled from public signals: careers pages, eng blogs, GitHub orgs.**

### What does this Actor do?

Every modern engineering org is quietly rewiring around AI dev tools — **Cursor, Claude Code, GitHub Copilot, Windsurf, Cody, Codeium, Aider, Continue, Tabnine, Cline**. But there is no public registry of "who uses what."

This Actor reconstructs an org's AI tool stack from **four public signals**:

1. **Careers pages**: scrapes `/careers`, `/jobs`, follows job posts on Greenhouse / Lever / Ashby / Workable / Smartrecruiters. A line that says "Experience with Cursor or GitHub Copilot a plus" is high-confidence evidence.
2. **Engineering blog**: scrapes `/blog`, `/engineering`, follows recent posts. "We adopted Claude Code last quarter" is gold.
3. **GitHub org**: discovers the org via direct slug + search, then checks the top 20 most-recently-updated repos for filesystem markers (`.cursorrules`, `CLAUDE.md`, `.windsurfrules`, `.github/copilot-instructions.md`, `.continuerc.json`, etc).
4. **Homepage + docs**: scans the homepage, `/docs`, and `/about` for any tool name drops.

Every detection includes the source URL and the matching snippet. Confidence is weighted — explicit job-listing mentions beat repo-marker presence, which beats a generic homepage word match.

### Why use AI Tool Stack Detector?

- **AI dev-tool sales**: build a target list of "Cursor users" / "Copilot users" / "no-AI orgs" without scraping LinkedIn
- **Competitive intelligence**: track which orgs are migrating from Copilot to Cursor in real time
- **Engineering hiring**: align your candidate pitch to the tools the target uses
- **Investor research**: identify the orgs that have *actually* adopted AI tools vs. announced they would
- **Internal benchmarks**: see what your competitors' eng teams are running

### How to use AI Tool Stack Detector

1. Enter the **company name** (e.g. `Vercel`, `Stripe`, `Anthropic`)
2. (Optional) Provide **homepageUrl** to skip discovery
3. (Optional) Pick which **signalsToCheck** to run — default is all four
4. Click **Start**
5. Open the dataset row to see the full confidence-scored profile

### Input

- **`company`** (string, required) — e.g. `"Vercel"`
- **`homepageUrl`** (string, optional) — skip homepage discovery
- **`signalsToCheck`** (array, default `["careers", "blog", "github-org", "docs"]`) — subset to run

Example:

```json
{
  "company": "Vercel",
  "homepageUrl": "https://vercel.com",
  "signalsToCheck": ["careers", "github-org"]
}
````

### Output

```json
{
  "company": "Vercel",
  "homepageUrl": "https://vercel.com",
  "githubOrg": "vercel",
  "aiToolsDetected": {
    "cursor": {
      "confidence": 0.9,
      "evidence": [
        "careers:https://vercel.com/careers/... → \"Cursor IDE\"",
        "github:vercel/next.js → \"Found .cursor/\""
      ],
      "signalCount": 5
    },
    "claude-code": {
      "confidence": 0.7,
      "evidence": ["github:vercel/turbo → \"Found CLAUDE.md\""],
      "signalCount": 2
    },
    "copilot": {
      "confidence": 0.5,
      "evidence": ["blog:.../post → \"GitHub Copilot\""],
      "signalCount": 1
    }
  },
  "primaryStack": "cursor",
  "signalsAnalyzed": 18,
  "timestamp": "2026-05-21T01:30:00Z"
}
```

Download as JSON, CSV, HTML, or Excel.

### Data table

| Field | Meaning |
|---|---|
| `aiToolsDetected[tool].confidence` | 0.0 to 0.99 — weighted by source strength |
| `aiToolsDetected[tool].evidence` | Up to 5 evidence snippets with source URL |
| `aiToolsDetected[tool].signalCount` | Raw mention count |
| `primaryStack` | Tool with highest confidence |
| `signalsAnalyzed` | Total pages + repos scanned |

### Pricing

- **First detection**: free trial
- **Per-company rate**: $0.10 per company scanned
- **Batch (50 companies)**: $4
- **Monthly subscription**: $10/month for unlimited scans + weekly refresh

### Tips

- Set `GITHUB_TOKEN` env var to a personal access token — anonymous GitHub API is harshly rate-limited
- Run with `signalsToCheck: ["careers"]` for fastest scans (skips repo-by-repo GitHub checks)
- Schedule weekly and diff: catch the day a competitor switches from Copilot to Cursor
- Pair with [`gh-org-ai-fingerprinter`](https://github.com/ianymu) for deep GitHub-only fingerprinting

### FAQ

#### How accurate is the detection?

We never claim 100% certainty — we publish a confidence score (0.0-0.99) and the evidence. A 0.9 score means "multiple high-weight signals from multiple sources." A 0.4 score means "one ambiguous mention." Use confidence as a filter, not a binary.

#### What if a company has no public GitHub org?

The Actor falls back to careers + blog + homepage signals. No GitHub means lower max signal count, not failure.

#### Is this legal?

Yes — every signal is publicly indexed content (careers pages, blog posts, public GitHub repos). The Actor obeys robots-friendly pacing and never logs in. Do not use the output for adversarial outreach or anti-recruiting.

#### Why no Playwright?

We use `axios` only. Most careers + blog content renders server-side. Browser-based scraping is 30x slower and unnecessary for the 95%-case.

### Support

Issues / feature requests: open in the **Issues** tab on the Apify console.

Built by **Ian Mu** — [github.com/ianymu](https://github.com/ianymu) — author of [`claude-verify-before-stop`](https://github.com/ianymu/claude-verify-before-stop), part of his 100-actor Apify portfolio.

# Actor input Schema

## `company` (type: `string`):

Company to analyze, e.g. "Vercel", "Stripe", "Anthropic".

## `homepageUrl` (type: `string`):

Skip homepage discovery by providing the URL directly. e.g. https://vercel.com

## `signalsToCheck` (type: `array`):

Which public signal sources to scan

## Actor input object example

```json
{
  "company": "Vercel",
  "signalsToCheck": [
    "careers",
    "blog",
    "github-org",
    "docs"
  ]
}
```

# 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 = {
    "company": "Vercel"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ianymu/ai-tool-stack-detector").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": "Vercel" }

# Run the Actor and wait for it to finish
run = client.actor("ianymu/ai-tool-stack-detector").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 '{
  "company": "Vercel"
}' |
apify call ianymu/ai-tool-stack-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/ai-tool-stack-detector",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Tool Stack Detector",
        "description": "Detect which AI dev tools (Cursor, Claude Code, Copilot, Windsurf, Cody, Codeium, Aider, Continue, Tabnine, Cline) any company's engineering team uses. Aggregates public signals: careers pages, engineering blog, GitHub org repo markers. Returns confidence-scored profile with evidence.",
        "version": "0.0",
        "x-build-id": "1VwaMoyPhAiVfqmkH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~ai-tool-stack-detector/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-ai-tool-stack-detector",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ianymu~ai-tool-stack-detector/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-ai-tool-stack-detector",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ianymu~ai-tool-stack-detector/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-ai-tool-stack-detector",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "company"
                ],
                "properties": {
                    "company": {
                        "title": "Company name",
                        "type": "string",
                        "description": "Company to analyze, e.g. \"Vercel\", \"Stripe\", \"Anthropic\"."
                    },
                    "homepageUrl": {
                        "title": "Homepage URL (optional)",
                        "type": "string",
                        "description": "Skip homepage discovery by providing the URL directly. e.g. https://vercel.com"
                    },
                    "signalsToCheck": {
                        "title": "Signals to check",
                        "type": "array",
                        "description": "Which public signal sources to scan",
                        "default": [
                            "careers",
                            "blog",
                            "github-org",
                            "docs"
                        ],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```