# Website Technology & Tag Change Monitor (`produkdigitalali/website-technology-tag-change-monitor`) Actor

Detect website technologies, analytics, ad pixels, tag managers, CDNs, payment tools, and third-party scripts. Save snapshots and monitor additions or removals.

- **URL**: https://apify.com/produkdigitalali/website-technology-tag-change-monitor.md
- **Developed by:** [ProdukDigitalAli](https://apify.com/produkdigitalali) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 completed domain scans

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

## Website Technology & Tracking Tag Change Monitor

Detect a website's technology stack and tracking tags, save a private baseline, and see what was added or removed on later runs.

### Quick start

Snapshot a public page:

```json
{
  "websites": ["https://example.com"],
  "mode": "snapshot"
}
```

Monitor changes on a schedule:

```json
{
  "websites": ["https://example.com"],
  "mode": "compare",
  "monitorKey": "use-a-private-random-value-at-least-16-characters"
}
```

The monitor key is encrypted by Apify. Reuse the same value for later scheduled runs. Never put passwords, tokens, or cookies in URLs.

### What it detects

The versioned signature registry covers common CMS, ecommerce, website builders, JavaScript frameworks, analytics, tag managers, advertising pixels, CRM/chat, consent tools, payments, monitoring, CDN, and hosting signals. Examples include WordPress, Shopify, Next.js, React, Google Tag Manager, Google Analytics, Meta Pixel, TikTok Pixel, HubSpot, OneTrust, Stripe, Sentry, Cloudflare, and Vercel.

Each technology contains:

- stable ID and name
- category
- confidence
- compact evidence labels when enabled

This HTTP-first beta inspects response headers, returned HTML, declared scripts/resources, and cookie names. It does not claim a declared tracking tag actually fired in a real browser.

### Snapshot and compare behavior

In `snapshot` mode, the Actor returns current detections without persistent monitoring state.

In `compare` mode:

1. The first successful run creates a baseline.
2. The next run loads that baseline.
3. Output reports technologies and third-party domains added, removed, or changed.
4. The successful current snapshot becomes the next baseline.

State identity includes a cryptographic hash of the secret monitor key, domain, signature version, and representative paths. The secret itself is never stored in output.

### Output

One summary row is produced per domain. Successful rows contain:

```json
{
  "recordType": "summary",
  "success": true,
  "domain": "example.com",
  "technologyCount": 1,
  "technologies": [{"id": "cloudflare", "name": "Cloudflare", "category": "CDN and security", "confidence": "medium"}],
  "changes": {
    "added": [],
    "removed": [],
    "changed": [],
    "domainsAdded": [],
    "domainsRemoved": [],
    "counts": {"added": 0, "removed": 0, "changed": 0, "domainsAdded": 0, "domainsRemoved": 0}
  }
}
```

Failures have fixed error codes and are not charged: `INVALID_INPUT`, `INVALID_URL`, `MONITOR_KEY_REQUIRED`, `NETWORK_BLOCKED`, `UNSUPPORTED_CONTENT`, `RESPONSE_TOO_LARGE`, `TOO_MANY_REDIRECTS`, `REQUEST_TIMEOUT`, or `SCAN_FAILED`.

### Pricing

The launch hypothesis is **US$0.012 per successfully completed domain scan**. Failed domains are not charged. The synthetic Actor-start event uses Apify's recommended default. The run-level `maxTotalChargeUsd` remains authoritative, and `maxUserChargeUsd` provides an additional input-side domain cap.

Examples before Store discounts:

- 10 successful domains: about US$0.12 plus the small startup event.
- 100 successful domains: about US$1.20 plus the startup event.
- A failed domain: no completed-domain-scan event.

### Limits and safety

- Up to 50 websites per run.
- One to five same-domain pages per website.
- Maximum 10 concurrent domains.
- Response body maximum 5 MB per page; default 2 MB.
- Request timeout 5-60 seconds; default 20.
- Public HTTP(S) ports 80/443 only.
- Private and special networks are blocked and redirects are rechecked.
- Credentials, cookie values, authorization headers, query strings, and response bodies are not written to output.
- HTTP-only detection can miss technologies injected only after JavaScript execution and may report a declared integration that is inactive.

### Use cases

- Monitor when a competitor adds or removes analytics or advertising tags.
- Find websites using a technology and export auditable evidence.
- Track weekly SaaS technology-stack changes.
- Audit agency or lead lists for CMS, payment, consent, and marketing tools.

### Ready-to-use examples

- `examples/01-technology-audit.json` scans two domains with evidence.
- `examples/02-weekly-change-monitor.json` creates and updates a private comparison baseline.
- `examples/03-multi-page-stack-scan.json` checks a homepage and one representative path.

### Support

Include the Actor run ID, a public reproduction URL, mode, and unexpected technology ID. Never post monitor keys, API tokens, cookies, or private-site data.

# Actor input Schema

## `websites` (type: `array`):

Public HTTP(S) website URLs to inspect. Maximum 50.

## `mode` (type: `string`):

Snapshot returns current detections. Compare also loads and replaces prior state.

## `monitorKey` (type: `string`):

Required in compare mode. Reuse the same private value on scheduled runs to isolate history.

## `representativePaths` (type: `array`):

Optional same-domain paths such as /pricing. Maximum four extra paths.

## `includeEvidenceRows` (type: `boolean`):

Add one compact evidence row per detected technology.

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

Hard page limit per website.

## `maxConcurrency` (type: `integer`):

HTTP scan concurrency limit.

## `requestTimeoutSeconds` (type: `integer`):

Timeout per page request.

## `maxResponseBytes` (type: `integer`):

Hard response-body limit per page.

## `maxUserChargeUsd` (type: `number`):

Actor event budget; platform maxTotalChargeUsd remains authoritative.

## Actor input object example

```json
{
  "websites": [
    "https://example.com"
  ],
  "mode": "snapshot",
  "representativePaths": [],
  "includeEvidenceRows": false,
  "maxPagesPerDomain": 1,
  "maxConcurrency": 3,
  "requestTimeoutSeconds": 20,
  "maxResponseBytes": 2000000,
  "maxUserChargeUsd": 0.15
}
```

# Actor output Schema

## `summary` (type: `string`):

No description

## `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 = {
    "websites": [
        "https://example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("produkdigitalali/website-technology-tag-change-monitor").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 = { "websites": ["https://example.com"] }

# Run the Actor and wait for it to finish
run = client.actor("produkdigitalali/website-technology-tag-change-monitor").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 '{
  "websites": [
    "https://example.com"
  ]
}' |
apify call produkdigitalali/website-technology-tag-change-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,produkdigitalali/website-technology-tag-change-monitor"
        }
    }
}
```

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/d2h0EsbedoxrZhbVQ/builds/JwDQNmk6PgVxKyN40/openapi.json