ForHosting KIT · Web Scraping & Monitoring

Detect a site's technology

A homepage never tells you what it's running on, but the markup, headers and script tags underneath it usually do. This endpoint fingerprints a site's stack — CMS, JavaScript framework, analytics, payment processor, CDN and dozens more — from a single URL, the same way a curious developer would inspect it by hand, only faster and at scale.

● StablePer request + per URL$0.040

Run — $0.040 + $0.001/URL How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Why 'what's this built with' comes up so often

Sales teams researching a prospect want to know if they're already on a competing platform before a call. Agencies scoping a redesign want to know what they're inheriting before quoting a price. Market researchers tracking a category want to know which CMS or e-commerce platform is gaining share among a set of competitors. All three are the same underlying question — what is this site actually built with — and until now the honest answer required opening dev tools on every single URL by hand.

How the fingerprinting works

POST /web/tech-detect with one or more URLs, get a task_id back immediately, and receive a structured breakdown by signed webhook or a signed link once the async task completes. Detection works by matching signatures in HTML markup, response headers, cookies, script sources and meta tags against known patterns left behind by specific software — a particular meta generator tag, a script loaded from a distinctive path, a cookie name unique to one platform — the same clues a person would notice, just checked systematically rather than by memory.

A fingerprinting approach, not a guess

This kind of detection has existed in browser extensions and standalone tools for years precisely because so much of a site's stack leaves visible traces in what it serves to a browser, even when nothing about the visual design gives it away. It's not infallible — a site can be built to obscure its stack, and detection reflects what's publicly observable rather than internal infrastructure — but for the overwhelming majority of sites built on mainstream platforms, the visible signatures are there and consistent.

Running it across many sites at once

Because the endpoint accepts a batch of URLs in one call, it fits naturally into workflows that need the same answer repeated across a list: a sales team enriching a lead list with the prospect's current platform, an analyst tracking framework adoption across a set of competitor domains, an agency auditing every site in a client's portfolio before proposing consolidation. Priced per request plus per URL, running it across a long list costs in direct proportion to how many sites you actually check, so a small pilot and a full-portfolio run land on the same rate.

What you can do with it

Sales prospect research

A sales rep detects a prospect's current CMS and analytics stack before a discovery call to tailor the pitch around what they'd actually be replacing.

Redesign scoping for agencies

An agency runs detection on a client's existing site before quoting a rebuild, to know upfront whether it's inheriting a headless setup, a legacy CMS or a page builder.

Competitive platform tracking

A market analyst scans a list of competitor domains periodically to track which e-commerce platform or framework is gaining adoption in a category.

Portfolio-wide stack audit

An agency managing dozens of client sites runs a batch detection to find which ones still run an outdated plugin or unsupported framework.

FAQ

How do I find out what technology a website uses with the API?

POST the URL to /web/tech-detect, keep the returned task_id, and collect the technology breakdown by webhook or a signed link valid for 24 hours.

Is the website technology detection API free?

No, there is no free tier or trial; it costs $0.040 per request plus $0.001 per URL, and a failed task is never charged.

What kinds of technology does it detect?

CMS platforms, JavaScript frameworks, analytics and tag managers, e-commerce and payment tools, CDNs, and other software that leaves a visible signature in a site's markup, headers or scripts.

Can I check multiple sites in one request?

Yes, the endpoint accepts a batch of URLs in a single call, which is priced per request plus per URL checked.

How accurate is technology detection?

It's based on matching known public signatures in a site's markup and network responses, so it's reliable for mainstream platforms but reflects what's publicly observable rather than internal infrastructure.

Does it detect hosting or server infrastructure?

It reports what's visible from the outside, such as CDN and server headers, but not private internal infrastructure that never reaches the browser.

Is this endpoint live yet?

Yes, it's live and accepting requests now.

Is the scanned page data kept afterward?

No, page content and results are deleted after the retention window and are never used for training.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/web/tech-detect

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/web/tech-detect \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"url":"https://ejemplo.com"}'

const res = await fetch("https://api.kit.forhosting.com/web/tech-detect", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "url": "https://ejemplo.com"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/web/tech-detect",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/tech-detect", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"url":"https://ejemplo.com"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"url":"https://ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/tech-detect", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "url": "https://ejemplo.com"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "web.tech_detect",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.040

Per URL$0.001

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`timeout_sec`	30
`max_crawl_pages`	25

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →