PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchTo label a list of domains by visible Shopify, WordPress, or HubSpot signals, query a technology lookup API and save the provider’s evidence, scan mode, status, and timestamps alongside each original lead. Python can automate the CSV handling and requests, but no detector can guarantee it will find every site that actually uses those tools: a “no match” means only that the chosen provider returned no target technology for that domain under that scan mode.
Choose a lookup method for the size and needs of your list
For recurring lead enrichment, use a technology lookup service rather than trying to infer a stack from a single page element. Detection services examine observable fingerprints such as HTML, JavaScript variables, response headers, DOM elements, scripts, and metadata. A match is evidence that a signal was visible to the detector—not proof of every tool a company uses internally, or that the technology is used across every subdomain.
As an Amazon Associate I earn from qualifying purchases.
| Option | Best fit | Input and completion | Evidence and caveats |
|---|---|---|---|
| Wappalyzer API | Enriching a supplied list with technology results | Lookup accepts one to ten website URLs per request by default; documented limit is ten URLs per request and ten requests per second. Results may be cached, live, or asynchronous for some scans. | Returns technology lookup data; preserve the response and query mode. API access, plans, limits, and credit costs should be checked before implementation. Wappalyzer lookup API documentation |
| BuiltWith Domain API | Checking domains you already have | Supports multi-domain lookups and a bulk job flow for large batches; bulk processing may be asynchronous. | Requires an API key. The documentation describes domain lookup but does not establish an accuracy advantage over Wappalyzer. BuiltWith Domain API documentation |
| BuiltWith Lists API | Finding websites by technology, rather than checking only a supplied lead list | Can combine a main technology with additional technologies. | It serves a different discovery use case from the Domain API. BuiltWith Lists API documentation |
Wappalyzer describes its API as a way to look up sites and enrich lead lists in its API overview. Its documentation says cached data is the default; a request can select real-time scanning with live=true. Recursive lookup follows internal links for broader coverage. If a result is absent or a live recursive scan is requested, the initial response may indicate that a crawl is underway without including technologies; use a callback or check again later. Wappalyzer says a crawl can take up to 15 minutes.
Under Wappalyzer’s documented credit scheme, a normal lookup costs one credit per URL, while combining live=true and recursive=true costs five credits per URL. These documented values and API limits may change; verify the current plan and pricing before estimating a recurring job. The lookup documentation also says older verification windows are more likely to include sites that have since stopped using a technology. Its denoise option excludes low-confidence detections by default; loosening that filter can return more results, with greater false-positive risk.
#1 Best Overall
There is no cited apples-to-apples evaluation establishing which provider is more accurate for Shopify, WordPress, or HubSpot. Choose based on list scale, freshness needs, completion workflow, evidence fields, access, and budget—not an unsupported accuracy ranking.
Build an auditable CSV enrichment workflow
Keep the source row intact and create separate fields for the normalized query and the result. Do not silently drop rows when a lookup fails or returns no technologies. Python’s standard library provides csv for reading and writing CSV files and urllib.request for HTTP requests; see the CSV documentation and urllib.request documentation. A maintained HTTP library is another option.
- Read the input and retain identity. Keep the original lead value and a stable row identifier, such as an existing lead ID or input row number. This lets you join results back to the source even if domains repeat.
- Normalize conservatively. Trim whitespace, remove an accidental trailing slash, and standardize obvious URL variations such as a missing scheme. Preserve the original value. Do not merge
www.example.com,shop.example.com, or other subdomains unless your matching rule explicitly says they represent the same lookup target. - Submit supported batches. Send only the number of URLs supported by the selected API. For Wappalyzer’s documented lookup endpoint, that means at most ten URLs in a request and no more than ten requests per second. Store the provider and scan mode with every request so that cached and live results are distinguishable.
- Match target names without discarding context. Compare returned technology names or provider slugs with Shopify, WordPress, and HubSpot. Save both the target labels and the complete returned technology list; the full list makes later review possible if naming or matching rules change.
- Write a result for every input row. Use explicit statuses such as
detected,no technology returned,lookup failed, orpending. A blank technology cell alone cannot tell a reviewer whether the domain was checked, the request failed, or a crawl has not finished. - Keep timestamps and review flags. Record when you checked and any provider confirmation or verification time returned. Send stale, uncertain, or commercially consequential detections for manual review before treating them as qualified leads.
A practical output schema is:
lead_idandoriginal_domainnormalized_urlproviderandscan_mode(for example, cached or live)detected_technologiesandtarget_labelslookup_statusanderror_or_pending_detailschecked_atandprovider_confirmed_at, when supplied- A raw-response file or stable response reference, where permitted by the provider’s terms
The fields above are an auditability recommendation, not a schema either provider requires. Protect API keys as secrets rather than placing them in the CSV or source code, and confirm the provider’s terms before retaining raw responses.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesCall an API from Python without losing status or evidence
The following pattern uses Python’s standard library and a generic JSON API shape. It shows how to make a request and preserve response data; it is not a drop-in client for either provider. Set the endpoint, authentication header, request body, response parsing, batching, and asynchronous handling to match the provider’s current documentation. Do not assume an API key or access plan is free.
import csv
import json
import os
import urllib.error
import urllib.request
from datetime import datetime, timezone
API_URL = os.environ["TECH_LOOKUP_URL"]
API_KEY = os.environ["TECH_LOOKUP_API_KEY"]
def lookup(urls):
payload = json.dumps({"urls": urls}).encode("utf-8")
request = urllib.request.Request(
API_URL,
data=payload,
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
},
method="POST",
)
try:
with urllib.request.urlopen(request, timeout=60) as response:
raw = response.read().decode("utf-8")
return "received", json.loads(raw), ""
except urllib.error.HTTPError as exc:
detail = exc.read().decode("utf-8", errors="replace")
return "lookup failed", None, f"HTTP {exc.code}: {detail}"
except (urllib.error.URLError, TimeoutError) as exc:
return "lookup failed", None, str(exc)
checked_at = datetime.now(timezone.utc).isoformat()
After parsing a provider response, map its actual fields into your output schema rather than assuming that every successful HTTP response contains completed technologies. If the provider reports a crawl or job in progress, save its identifier and mark the row pending; poll or accept a callback according to the provider’s documented workflow, then update the row when results arrive. Keep errors separate from empty result sets.
Interpret matches and non-matches carefully
Public-page fingerprints can reveal a technology without establishing how broadly it is used. A company may use HubSpot internally without exposing a detectable signal on its public website. Conversely, a detected signal can be stale or apply only to one subdomain. Neither the sources cited here establish a universal recall rate for these three technologies, so the workflow cannot promise to find every actual user.
- Detected: the provider returned a target technology for the queried domain and scan mode. Retain the returned evidence and its age.
- No technology returned: no target was returned in that lookup. It does not prove the organization does not use the platform.
- Lookup failed: the request did not produce a usable result; fix the cause and retry rather than labeling the domain as a non-match.
- Pending: the provider has not completed an asynchronous scan or bulk job. Do not count it as a final negative.
For a lead qualification decision, use the lookup as a signal for prioritization, not as the sole basis for a consequential claim. Review the live site or another reliable source when the result is stale, ambiguous, or important enough to warrant confirmation.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
