# Tech Stack Lookup - Company Vendor & SaaS Detection API (`amitmudaliyar/company-tech-stack-vendor-intelligence`) Actor

Give it a domain, get the SaaS vendors that company actually uses. Reads DNS verification records - the procurement trail HTML scanners miss - to surface AI tools, security, identity, CRM and collaboration vendors, plus email host and DMARC posture.

- **URL**: https://apify.com/amitmudaliyar/company-tech-stack-vendor-intelligence.md
- **Developed by:** [Amit Mudaliyar](https://apify.com/amitmudaliyar) (community)
- **Categories:** Lead generation, Automation, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 domain analyzeds

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

## Tech Stack Lookup — Company Vendor & SaaS Detection API

**Give it a domain. Find out which SaaS vendors that company actually uses.**

Not "what's on their website" — what's in their *company*. Their AI tools, identity provider, CRM, security stack, e-signature vendor, email host.

```
Input:   ["figma.com"]

Output:  36 vendors detected
         AI            Anthropic (Claude), Cursor, OpenAI, Decagon, GC AI
         Security      1Password, Jamf, Wiz
         Collaboration Atlassian, Notion, Dropbox, Zoom
         Dev tools     Linear, MongoDB, Postman, Gradle
         Email         Google Workspace     DNS  AWS Route 53
```

***

### Why this finds things other tools miss

Most tech-detection tools read the homepage: they see your analytics tag and your CDN, and stop there. Almost nothing a company *runs internally* appears in HTML.

This Actor reads **DNS verification records** as well.

When a company adopts a SaaS product, that vendor usually asks them to prove domain ownership by publishing a TXT record. Those records are public, permanent, and they accumulate — every one is a vendor relationship the company confirmed itself. It's the difference between seeing a marketing pixel and seeing the actual procurement trail.

That's why this tool surfaces **Cursor, Anthropic, Jamf, 1Password, Wiz, Linear, DocuSign** — things no HTML scanner will ever see.

Signals combined:

| Source | What it reveals |
| --- | --- |
| **DNS TXT** | Confirmed vendor relationships — AI tools, security, identity, collaboration |
| **MX** | Email host (Google Workspace, Microsoft 365, Proofpoint, Mimecast) |
| **SPF includes** | Who sends mail on their behalf — Zendesk, Salesforce, Marketo, SendGrid |
| **DMARC** | Email-security posture (`none` / `quarantine` / `reject`) |
| **NS** | DNS and CDN provider |
| **HTTP headers** | Hosting, CDN, framework |
| **Homepage HTML** | Analytics, chat widgets, CMS, pixels, payments |

No proxies, no headless browsers, no login. Just public infrastructure records — which is why a domain profiles in **about a second**.

### What you can do with it

**Sell to companies that already use a category.**
Find every account running Drift, and pitch the replacement. `vendorFilter: ["drift"]`.

**Find AI adopters.**
`categories: ["ai"]` tells you who has already put Anthropic, OpenAI or Cursor into production — the single fastest-moving buying signal in B2B right now, and one that barely exists in commercial datasets yet.

**Qualify inbound.**
A signup lands. Before the first call, know their stack, their scale, and their security posture.

**Competitive displacement.**
Track which vendors your target accounts adopt and drop over time by re-running on a schedule.

**Security and vendor due diligence.**
Check DMARC policy and see the third-party surface area of an acquisition target.

> **Pairs with [ATS Jobs Scraper & Hiring Signals](https://apify.com/amitmudaliyar/company-jobs-hiring-signals)** — that one tells you *who a company is hiring*, this one tells you *what they buy*. Same input, same account list, two halves of the same picture.

***

### Input

```json
{
  "domains": ["figma.com", "monzo.com", "gitlab.com"],
  "categories": ["ai", "security"],
  "includePageSignals": true
}
```

| Option | Default | What it does |
| --- | --- | --- |
| `domains` | *required* | Bare domains or full URLs. |
| `categories` | `[]` | Keep only these categories — `ai`, `security`, `crm-sales`, … |
| `vendorFilter` | `[]` | Keep only vendors matching these strings, e.g. `["openai"]`. |
| `includePageSignals` | `true` | Also fetch the homepage. Turn off for a faster, pure-DNS run. |
| `outputVendorRows` | `false` | Adds a flat row per vendor — good for CSV and pivot tables. |
| `includeRawDns` | `false` | Adds MX, nameservers, SPF includes and unrecognised TXT prefixes. |
| `concurrency` | `8` | Domains profiled in parallel. |

***

### Output

One `domain-profile` per domain:

```json
{
  "type": "domain-profile",
  "domain": "figma.com",
  "siteTitle": "Figma: The collaborative canvas for design, code, and AI",
  "vendorCount": 36,
  "aiTools": ["Anthropic (Claude)", "Cursor", "Decagon", "GC AI", "OpenAI"],
  "securityTools": ["1Password", "Jamf", "Wiz"],
  "devTools": ["Gradle", "Linear", "MongoDB", "Postman"],
  "collaborationTools": ["Atlassian", "Dropbox", "Notion", "Zoom"],
  "emailProvider": "Google Workspace",
  "dnsProvider": "AWS Route 53",
  "hasSpf": true,
  "hasDmarc": true,
  "dmarcPolicy": "quarantine",
  "byCategory": { "ai": 5, "collaboration": 4, "devtools": 4, "security": 3 },
  "vendors": [
    {
      "vendor": "Anthropic (Claude)",
      "category": "ai",
      "categoryLabel": "AI & LLM tools",
      "sources": ["dns-txt"],
      "evidence": "anthropic-domain-verification-4rt01s=L6y4AAr..."
    }
  ]
}
```

**Every detection carries its evidence.** You can see exactly which record produced it, so nothing is a black box and you can verify any result yourself with a `dig` command.

Set `outputVendorRows: true` to also get one flat row per vendor — the shape you want for a spreadsheet or a CRM import.

***

### Honest limits

**Absence is not proof.** A vendor missing from the output means no public signal was found — not that the company doesn't use it. Plenty of SaaS products never require a DNS record. Read this as *high-confidence positives*, not a complete inventory.

**Verification records can outlive the contract.** Companies rarely clean up DNS after churning a vendor, so a record can linger past cancellation. Treat detections as "has a relationship with", not "is currently paying for".

**Coverage is strongest where fingerprints are public.** The vendor knowledge base was built from fingerprints sampled across real company domains and grows over time. Anything unrecognised is returned in `unmatchedTxtPrefixes` (with `includeRawDns: true`) rather than silently dropped — so you can see what was found but not yet named.

**Only public records are read.** No logins, no personal data, no private endpoints. Everything here is visible to anyone running `dig`.

### Pricing

Pay per event — one charge per domain successfully profiled, however many vendors come back. Domains with no DNS records at all aren't charged.

### Support

Spotted a vendor fingerprint that isn't recognised yet? Open an issue with the TXT prefix and it'll be added — the knowledge base improves with every report.

***

### More from this creator

Three Actors, one account-intelligence picture — all built on official public APIs, no proxies:

| Actor | Answers |
| --- | --- |
| [ATS Jobs Scraper & Hiring Signals](https://apify.com/amitmudaliyar/company-jobs-hiring-signals) | Who is a company **hiring**? Open roles from nine ATS platforms plus a scored hiring-momentum report. |
| **Tech Stack Lookup** (this one) | What does a company **buy**? AI tools, CRM, security and analytics vendors, detected from public DNS records. |
| [App Store Intelligence & ASO](https://apify.com/amitmudaliyar/app-store-intelligence-aso) | How does an app **perform**? Ratings, rankings and ASO across every country storefront. |

# Actor input Schema

## `domains` (type: `array`):

Company domains to profile. Accepts bare domains or full URLs — figma.com, https://www.monzo.com, etc.

## `categories` (type: `array`):

Keep only vendors in these categories. Leave empty for everything.

## `vendorFilter` (type: `array`):

Keep only vendors whose name contains one of these strings, e.g. "openai", "drift". Great for building a target list of companies that already use a specific product.

## `includePageSignals` (type: `boolean`):

Also fetch the homepage to detect analytics, chat widgets, CMS and frameworks. Turn off for a pure DNS run, which is faster and works even when a site blocks bots.

## `outputVendorRows` (type: `boolean`):

Adds a flat row per detected vendor alongside the domain profile. Handy for CSV exports and pivot tables.

## `includeRawDns` (type: `boolean`):

Adds MX records, nameservers, SPF includes and any unrecognised TXT prefixes to each profile.

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

How many domains to profile in parallel.

## Actor input object example

```json
{
  "domains": [
    "figma.com",
    "monzo.com",
    "gitlab.com",
    "ramp.com",
    "notion.so"
  ],
  "categories": [],
  "vendorFilter": [],
  "includePageSignals": true,
  "outputVendorRows": false,
  "includeRawDns": false,
  "concurrency": 8
}
```

# Actor output Schema

## `profiles` (type: `string`):

One record per domain: detected vendors, category breakdown, email and DNS providers, and email-security posture.

## `vendors` (type: `string`):

One flat row per detected vendor (requires the 'Also output one row per vendor' option).

## `downloadCsv` (type: `string`):

No description

## `runSummary` (type: `string`):

Totals, vendor-frequency leaderboard across all domains, and any domains with no DNS signal.

# 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 = {
    "domains": [
        "figma.com",
        "monzo.com",
        "gitlab.com",
        "ramp.com",
        "notion.so"
    ],
    "categories": [],
    "vendorFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("amitmudaliyar/company-tech-stack-vendor-intelligence").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 = {
    "domains": [
        "figma.com",
        "monzo.com",
        "gitlab.com",
        "ramp.com",
        "notion.so",
    ],
    "categories": [],
    "vendorFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("amitmudaliyar/company-tech-stack-vendor-intelligence").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 '{
  "domains": [
    "figma.com",
    "monzo.com",
    "gitlab.com",
    "ramp.com",
    "notion.so"
  ],
  "categories": [],
  "vendorFilter": []
}' |
apify call amitmudaliyar/company-tech-stack-vendor-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,amitmudaliyar/company-tech-stack-vendor-intelligence"
        }
    }
}

```

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/7FdSE5gbbWVripwh3/builds/J40cFCe2CuEG3aIZu/openapi.json