# Website Tech Stack & Buying Intent Scanner (`express_kingfisher/website-tech-intent-scanner`) Actor

Detect technologies, CMS, analytics, ad pixels, and buying intent signals from any website. Bulk scan domains for B2B sales qualification and lead scoring.

- **URL**: https://apify.com/express\_kingfisher/website-tech-intent-scanner.md
- **Developed by:** [Prince Raj](https://apify.com/express_kingfisher) (community)
- **Categories:** 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

## Website Tech Stack & Buying Intent Scanner

Detect technology stacks, buying intent signals, and lead scores for B2B prospects. Built for sales teams, agencies, and RevOps who need to identify high-intent accounts at scale.

### What It Extracts

- **Technology stack**: CMS, frameworks, analytics, ad pixels, payment processors, CRMs
- **Buying intent signals**: Pricing page presence, careers page, contact forms, technology adoption stage
- **Lead scoring**: Composite score based on technology signals, page presence, and intent indicators
- **Contact signals**: Social links, email addresses, contact page URLs
- **Marketing stack**: Meta Pixel, Google Ads, TikTok Pixel, GA4, GTM, Hotjar, Clarity

### Why It's Better

Unlike basic tech scanners (BuiltWith, Wappalyzer), this actor combines technology detection with buying intent analysis. You get not just what tech a site uses, but whether they're actively buying, hiring, or growing. Perfect for prioritizing outreach.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `domains` | string[] | required | Domains or URLs to scan (max 100) |
| `maxPagesPerDomain` | integer | 5 | Pages to crawl per domain (1-20) |
| `detectPixels` | boolean | true | Detect advertising pixels |
| `detectEmailConfig` | boolean | false | Check email provider signals |
| `detectJobsPage` | boolean | true | Check for careers/jobs page |
| `detectPricingPage` | boolean | true | Check for pricing page |
| `includeLeadScore` | boolean | true | Calculate lead quality score |

### Output Example

```json
{
  "domain": "apify.com",
  "statusCode": 200,
  "title": "Apify - Web Scraping and Automation Platform",
  "technologies": ["React", "Next.js", "Segment", "Intercom"],
  "cms": null,
  "frameworks": ["Next.js", "React"],
  "analytics": ["Segment", "GA4"],
  "adPixels": ["Google Ads"],
  "hasPricingPage": true,
  "hasCareersPage": true,
  "contactUrls": ["https://apify.com/contact"],
  "socialUrls": ["https://twitter.com/apify", "https://github.com/apify"],
  "leadScore": 85,
  "buyingIntentSignals": ["Has pricing page", "Active hiring", "Modern tech stack"],
  "confidence": 0.9,
  "scrapedAt": "2025-01-15T10:30:00Z"
}
````

### Use Cases

- **B2B prospecting**: Identify companies using specific technologies for targeted outreach
- **Competitive intelligence**: Monitor competitor technology adoption
- **Agency lead gen**: Build prospect lists for web development or marketing services
- **Sales prioritization**: Score leads based on technology fit and buying signals
- **Market research**: Analyze technology adoption trends across industries

### PPE Pricing

| Event | Description | Suggested Price |
|-------|-------------|-----------------|
| `domain-scanned` | One domain fully analyzed | $0.01 |
| `page-analyzed` | Additional page beyond homepage | $0.002 |

### Limitations

- Only detects client-side technologies (server-side tech requires more advanced fingerprinting)
- Lead scoring is heuristic-based, not ML-powered
- Cannot detect technologies behind authentication
- Rate limited to respect target sites

### Legal/Ethical Use

This actor only extracts publicly visible information from websites. It does not bypass authentication, access private data, or violate terms of service. Users are responsible for compliance with applicable laws.

### Local Run

```bash
cd actors/website-tech-intent-scanner
apify run --input-file .actor/sample_input.json
```

### Deploy

```bash
cd actors/website-tech-intent-scanner
apify push
```

### FAQ

**Q: How many domains can I scan at once?**
A: Up to 100 domains per run. Each domain triggers a separate PPE event.

**Q: Does it work with JavaScript-heavy sites?**
A: Yes, it uses Crawlee's CheerioCrawler which handles most SPA frameworks.

**Q: Can I add custom technology signatures?**
A: Not yet. The current version uses built-in detection patterns.

### Tags

tech stack scanner, website technology detector, B2B lead scoring, buying intent, sales intelligence, competitive analysis, web technology profiler, SaaS prospecting

# Actor input Schema

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

List of domains or URLs to analyze. Example: \["example.com", "https://another.com"]

## `maxPagesPerDomain` (type: `integer`):

Maximum number of pages to crawl per domain for technology detection.

## `detectPixels` (type: `boolean`):

Scan for advertising pixels (Meta, TikTok, Google Ads, etc.)

## `detectEmailConfig` (type: `boolean`):

Check for email provider signals (MX records, SPF, DKIM)

## `detectJobsPage` (type: `boolean`):

Check if the domain has a careers or jobs page (buying intent signal)

## `detectPricingPage` (type: `boolean`):

Check if the domain has a pricing page

## `includeLeadScore` (type: `boolean`):

Calculate a lead quality score based on detected signals

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "maxPagesPerDomain": 5,
  "detectPixels": true,
  "detectEmailConfig": false,
  "detectJobsPage": true,
  "detectPricingPage": true,
  "includeLeadScore": true
}
```

# 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": [
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("express_kingfisher/website-tech-intent-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 = { "domains": ["apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("express_kingfisher/website-tech-intent-scanner").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 '{
  "domains": [
    "apify.com"
  ]
}' |
apify call express_kingfisher/website-tech-intent-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=express_kingfisher/website-tech-intent-scanner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Tech Stack & Buying Intent Scanner",
        "description": "Detect technologies, CMS, analytics, ad pixels, and buying intent signals from any website. Bulk scan domains for B2B sales qualification and lead scoring.",
        "version": "1.0",
        "x-build-id": "kewbjAqyeHEbEMmRn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/express_kingfisher~website-tech-intent-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-express_kingfisher-website-tech-intent-scanner",
                "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/express_kingfisher~website-tech-intent-scanner/runs": {
            "post": {
                "operationId": "runs-sync-express_kingfisher-website-tech-intent-scanner",
                "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/express_kingfisher~website-tech-intent-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-express_kingfisher-website-tech-intent-scanner",
                "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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains to scan",
                        "maxItems": 100,
                        "type": "array",
                        "description": "List of domains or URLs to analyze. Example: [\"example.com\", \"https://another.com\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Max pages per domain",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl per domain for technology detection.",
                        "default": 5
                    },
                    "detectPixels": {
                        "title": "Detect ad pixels",
                        "type": "boolean",
                        "description": "Scan for advertising pixels (Meta, TikTok, Google Ads, etc.)",
                        "default": true
                    },
                    "detectEmailConfig": {
                        "title": "Detect email configuration",
                        "type": "boolean",
                        "description": "Check for email provider signals (MX records, SPF, DKIM)",
                        "default": false
                    },
                    "detectJobsPage": {
                        "title": "Detect careers/jobs page",
                        "type": "boolean",
                        "description": "Check if the domain has a careers or jobs page (buying intent signal)",
                        "default": true
                    },
                    "detectPricingPage": {
                        "title": "Detect pricing page",
                        "type": "boolean",
                        "description": "Check if the domain has a pricing page",
                        "default": true
                    },
                    "includeLeadScore": {
                        "title": "Include lead score",
                        "type": "boolean",
                        "description": "Calculate a lead quality score based on detected signals",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
