Track Website Tech Changes Over Time via API (2026)

When a competitor migrates from Heroku to AWS, they do not send you a press release. When an acquisition target quietly drops their in-house CMS for Shopify, the deal memo does not update itself. When a client removes their WAF and nobody notices for six weeks, the breach report will eventually mention it.

Technology stack changes are high-signal events. They reveal migrations in progress, buying intent, infrastructure risk, and strategic direction. The problem is that these changes happen silently, buried in HTTP headers, DNS records, and JavaScript bundles that nobody is monitoring.

The DetectZeStack API gives you three endpoints to track these changes programmatically: /changes for a structured change feed, /history for full snapshots with inline diffs, and /webhooks for real-time push notifications when something shifts.

The Three Endpoints

1. /changes — The Structured Change Feed

The GET /changes endpoint returns a feed of every technology change detected across scanned domains. Each time a domain is analyzed, DetectZeStack diffs the new snapshot against the previous one and records structured change events.

Three change types are tracked:

• added — a technology appeared that was not in the previous scan
• removed — a technology that was present before is now gone
• version_changed — the same technology is still present but at a different version

curl -s "https://detectzestack.p.rapidapi.com/changes?domain=stripe.com" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: detectzestack.p.rapidapi.com" | python3 -m json.tool

Response:

{
  "changes": [
    {
      "id": 4821,
      "domain": "stripe.com",
      "technology": "React",
      "change_type": "version_changed",
      "category": "JavaScript frameworks",
      "previous_version": "18.2.0",
      "new_version": "18.3.1",
      "created_at": "2026-04-09T14:22:00Z"
    },
    {
      "id": 4819,
      "domain": "stripe.com",
      "technology": "Google Tag Manager",
      "change_type": "removed",
      "category": "Tag managers",
      "created_at": "2026-04-07T08:15:00Z"
    }
  ],
  "count": 2,
  "history_days": 90,
  "tier": "pro"
}

Each change includes the technology name, category, change type, version details (when applicable), and a timestamp. The response also tells you how many days of history your tier provides and which tier you are on, so your application can display that context without hardcoding tier logic.

You can filter by domain or leave it blank to get changes across all domains you have scanned. For a deep dive on the /changes endpoint specifically, see Track Technology Changes Over Time with the /changes API.

2. /history — Full Snapshots with Inline Diffs

The GET /history endpoint returns timestamped snapshots of a domain's full technology stack. Each snapshot is a complete picture of every technology detected at that point in time.

curl -s "https://detectzestack.p.rapidapi.com/history?domain=example.com&include_changes=true" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: detectzestack.p.rapidapi.com" | python3 -m json.tool

When you add include_changes=true, each snapshot includes a changes array showing what was added, removed, or version-changed relative to the previous snapshot. This gives you both the full picture and the diff in a single API call.

The /history endpoint supports limit (up to 100, default 20) and offset parameters for pagination. This is useful for building timeline views or audit trails where you need to see the complete state at each point rather than just the deltas.

3. /webhooks — Push Notifications for Changes

Polling works, but getting notified is better. The /webhooks endpoints let you register a callback URL for any domain. When changes are detected during scheduled monitoring, DetectZeStack sends a POST to your URL with the change details.

Register a webhook:

curl -X POST "https://detectzestack.p.rapidapi.com/webhooks" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: detectzestack.p.rapidapi.com" \
  -H "Content-Type: application/json" \
  -d '{"domain": "competitor.com", "webhook_url": "https://your-server.com/hooks/techstack"}'

Response:

{
  "id": 42,
  "domain": "competitor.com",
  "webhook_url": "https://your-server.com/hooks/techstack",
  "hmac_secret": "a1b2c3d4e5f6..."
}

The hmac_secret is returned once at creation. Store it securely. Every webhook delivery includes an X-Webhook-Signature header with an HMAC-SHA256 signature so you can verify the payload came from DetectZeStack and was not tampered with.

When changes are detected, you receive a POST with the tech_stack.changed event:

{
  "event": "tech_stack.changed",
  "domain": "competitor.com",
  "changes": [
    {
      "type": "added",
      "technology": { "name": "Cloudflare", "categories": ["CDN"] },
      "new_version": ""
    },
    {
      "type": "removed",
      "technology": { "name": "Akamai", "categories": ["CDN"] },
      "previous_version": ""
    }
  ],
  "technologies": [ ... ],
  "meta": { "scan_time_ms": 1842, "detection_count": 23 },
  "timestamp": "2026-04-11T10:30:00Z"
}

You also receive tech_stack.analyzed events on every analysis, which include the full technology list without the changes array. This is useful for logging every scan result to your own database.

Manage your webhooks with these endpoints:

• POST /webhooks — create a new subscription
• GET /webhooks — list your active subscriptions
• PATCH /webhooks/{id} — update a subscription
• DELETE /webhooks/{id} — remove a subscription

Webhook URLs must use HTTPS. Delivery retries up to 3 times with exponential backoff (2s, 4s) if your endpoint returns a non-2xx status.

Use Cases

Migration Detection

Technology migrations are slow, messy, and almost never announced. A company moving from Angular to React does not flip a switch. They run both frameworks in parallel for weeks or months while migrating page by page. During that window, the change feed shows both "React added" and eventually "Angular removed" as distinct events.

This is useful for consulting firms tracking client migration progress, sales teams identifying prospects mid-migration (who may need help), and analysts monitoring portfolio companies. Instead of asking "have you finished the migration?" you can check the API and see exactly where things stand.

# Check if a specific domain has had any framework changes recently
curl -s "https://detectzestack.p.rapidapi.com/changes?domain=target-company.com" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: detectzestack.p.rapidapi.com" \
  | python3 -c "
import sys, json
data = json.load(sys.stdin)
for c in data['changes']:
    if c['category'] in ('JavaScript frameworks', 'Web frameworks'):
        print(f\"{c['change_type']}: {c['technology']} ({c['created_at']})\")"

Competitor Monitoring

When a competitor adds Stripe, they are launching payments. When they add Intercom, they are investing in customer success. When they switch from Google Analytics to a privacy-focused alternative, they are responding to market pressure or preparing for a European expansion.

Each of these changes is a data point that informs your own strategy. The webhook endpoint lets you set up monitoring for a list of competitors and get notified when anything shifts, rather than polling manually.

A typical setup: register webhooks for your top 10 competitors, route the notifications to a Slack channel, and review the feed weekly. The cost for monitoring 10 domains on the free tier is well within the 100 requests/month limit.

Investment Due Diligence

Investors and PE firms use technology stack data to validate claims made during due diligence. A startup that says they built their own infrastructure should not be running on Heroku. A company claiming enterprise-grade security should have HSTS and CSP headers configured.

The /history endpoint with include_changes=true gives you a timeline of every technology decision the company has made, going back up to a year depending on your plan. This is objective evidence that does not depend on what the founders choose to disclose.

Common patterns investors look for:

• Infrastructure upgrades — moving from shared hosting to AWS/GCP signals scale preparation
• Analytics additions — adding Mixpanel or Amplitude suggests they are getting serious about product metrics
• Payment integrations — adding Stripe or Adyen means revenue is live or imminent
• Security improvements — adding Cloudflare, WAF, or improving security headers indicates operational maturity
• Technology removals — dropping a CRM or analytics tool could signal churn or a pivot

Agency Client Monitoring

If you manage websites for multiple clients, the change feed catches things that slip through the cracks. A client's developer pushes a new deploy that accidentally removes the CSP header. A WordPress plugin update introduces a new tracking script. A CDN configuration change swaps the provider without anyone on the account team knowing.

Set up webhooks for each client domain and route change notifications to the appropriate account team. The tech_stack.changed event gives you exactly what changed, so you can triage without manually re-scanning every domain.

Pricing: DetectZeStack vs BuiltWith

BuiltWith is the incumbent for technology change tracking. Their plans that include historical data and change monitoring start at $295/month. Here is how DetectZeStack compares:

Here is the full pricing breakdown for DetectZeStack change tracking:

The key difference: BuiltWith gates change tracking behind their higher-tier plans. With DetectZeStack, every plan — including the free tier — has access to the change feed. The paid tiers increase the lookback window and the number of API requests, but the endpoints and data format are identical.

Building a Monitoring Pipeline

Here is a practical example: a Python script that monitors a list of competitor domains and sends a Slack notification when changes are detected.

import requests
import json

RAPIDAPI_KEY = "YOUR_API_KEY"
SLACK_WEBHOOK = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
DOMAINS = ["competitor1.com", "competitor2.com", "competitor3.com"]

headers = {
    "x-rapidapi-key": RAPIDAPI_KEY,
    "x-rapidapi-host": "detectzestack.p.rapidapi.com"
}

for domain in DOMAINS:
    resp = requests.get(
        f"https://detectzestack.p.rapidapi.com/changes?domain={domain}",
        headers=headers
    )
    data = resp.json()

    if data["count"] > 0:
        lines = []
        for c in data["changes"]:
            emoji = {"added": "+", "removed": "-", "version_changed": "~"}
            prefix = emoji.get(c["change_type"], "?")
            line = f"[{prefix}] {c['technology']} ({c['change_type']})"
            if c.get("previous_version") and c.get("new_version"):
                line += f" {c['previous_version']} -> {c['new_version']}"
            lines.append(line)

        message = f"*Tech changes on {domain}:*\n```\n" + "\n".join(lines) + "\n```"
        requests.post(SLACK_WEBHOOK, json={"text": message})

Run this on a daily cron job and your team gets a Slack notification whenever a monitored domain changes its tech stack. For real-time notifications without polling, use the /webhooks endpoint instead.

Interactive Monitoring Dashboard

If you prefer a visual interface, the DetectZeStack Monitor page lets you track technology changes for any domain interactively — no API key needed for basic monitoring. The API endpoints documented above give you the same data programmatically for integration into your own tools and workflows.