Tech Stack API: Get a Website's Tech Stack

You need to automatically detect what technologies a website uses—CMS, analytics, CDN, frameworks, and ad networks—so you can enrich signups, qualify leads, audit publisher inventory, or trigger integrations. By the end of this walkthrough, you’ll call a single endpoint to get a site’s tech stack, parse the identifiers you care about, and plug them into your data pipeline with caching, batching, and sensible fallbacks.

Why Klazify is the right API for extracting website tech stacks

When your workflow depends on knowing if a site runs a specific CMS, analytics tool, CDN, framework, or ad network, you need breadth and precision at scale. Klazify analyzes full-site content and signals to return a normalized list of technology identifiers you can act on immediately.

• Accurate detection with content-level analysis: Klazify analyzes actual page content and domain signals, which helps identify real, in-use technologies instead of relying solely on headers or metadata.
• Global coverage: Tech stacks on localized sites vary by region and language. Klazify’s analysis supports a global crawl surface so you can classify non-English domains reliably.
• Real-time analysis: Tech footprints change frequently as sites migrate or test new vendors. Klazify emphasizes up-to-date detection rather than static, stale lookups.
• Industry-level categorization available: In the same response family, you can also access website categorization mapped to IAB taxonomy. That’s valuable if you want to pair tech stack findings with content categories for compliance or targeting.
• Simple integration: REST-based, with one POST that returns a normalized array of technology identifiers (objects.company.tech). Add it to your data pipeline without introducing a new queue or schema gymnastics.
• Compliance and filtering: Build allow/deny lists for trackers or ad technologies, flag risky vendors, and standardize inventory checks using a canonical list of tech IDs.

For a quick overview of everything Klazify offers, visit klazify.com. If you’re ready to test an integration, head straight to the Register page to start a free trial.

The endpoint you’ll use to get a site’s tech stack

Use the tech stack endpoint to return technology identifiers for a domain. You’ll authenticate with a Bearer token and send the target URL in the JSON body.

• HTTP method: POST
• Endpoint: https://www.klazify.com/api/domain_tech
• Auth: Bearer YOUR_API_KEY
• Body: { "url": "..." }
• Response field you’ll parse: objects.company.tech (array of technology identifiers)

cURL example (copy/paste)

curl -X POST "https://www.klazify.com/api/domain_tech" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://cbsnews.com"}'

Notes:

• Replace YOUR_API_KEY with your token after signing up.
• Failed or unreachable calls are not billed.
• Starter is $39.99/mo with a 7-day trial.

JavaScript example: call the endpoint and extract the tech list

async function fetchTechStack(url) {
const res = await fetch("https://www.klazify.com/api/domain_tech", {
method: "POST",
headers: {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json"
},
body: JSON.stringify({ url })
});

if (!res.ok) {
// Non-2xx responses indicate a temporary or input error; you can retry or log.
throw new Error(`Klazify tech fetch failed: ${res.status} ${res.statusText}`);
}

const data = await res.json();

// Defensive parsing: objects and company may be null for unknown or brand-new domains
const tech = data?.objects?.company?.tech || [];
return tech; // Array of technology identifiers (e.g., "omniture_adobe_analytics")
}

// Example usage with simple in-memory cache
const cache = new Map();

async function getTechWithCache(domainUrl, ttlMs = 7 * 24 * 60 * 60 * 1000) {
const key = new URL(domainUrl).hostname; // cache per registrable domain in most cases
const now = Date.now();

const entry = cache.get(key);
if (entry && (now - entry.ts) < ttlMs) {
return entry.tech;
}

const tech = await fetchTechStack(domainUrl);
cache.set(key, { ts: now, tech });
return tech;
}

// Run
getTechWithCache("https://cbsnews.com")
.then(techList => {
// Route by need: auditing, enrichment, feature flags, etc.
console.log("Detected tech identifiers:", techList);
})
.catch(err => console.error(err));

The complete response format and fields you’ll actually use

The following is an official example showing the structure returned by Klazify when requesting domain intelligence. You will primarily use objects.company.tech for tech stack extraction, and you can optionally use categories, logo_url, similar_domains, and domain_registration_data for enrichment or QA workflows.

{
"domain": {
"categories": [
{
"confidence": 0.92,
"name": "/Computers & Electronics/Consumer Electronics",
"IAB-632-596": "Consumer Electronics/Technology & Computing/Consumer Electronics"
},
{
"confidence": 0.89,
"name": "/Internet & Telecom/Mobile & Wireless/Mobile Phones"
}
],
"social_media": null,
"logo_url": "https://klazify.s3.amazonaws.com/2110787991611585019600ed5fb1d1300.04730104.png"
},
"success": true,
"objects": {
"company": {
"url": "https://www.apple.com/",
"name": "Apple",
"city": "Cupertino",
"stateCode": "CA",
"countryCode": "US",
"employeesRange": "100K+",
"revenue": 274515000000,
"raised": null,
"tags": [
"E-commerce",
"Consumer Electronics",
"Mobile",
"B2C"
],
"tech": [
"omniture_adobe_analytics",
"atlassian_confluence",
"successfactors",
"apache_apex",
"talend",
"oracle_peoplesoft",
"salesforce",
"stripe",
"dell_boomi_atomsphere",
"gigya",
"sage_50cloud",
"quickbooks",
"webmethods",
"apache_tomcat",
"alteryx",
"tibco_rendezvous",
"atlassian_jira",
"..."
]
}
},
"domain_registration_data": {
"domain_age_date": "1987-02-19",
"domain_age_days_ago": "13026",
"domain_expiration_date": "2030-02-20",
"domain_expiration_days_left": "123"
},
"similar_domains": [
"bestbuy.com",
"icloud.com",
"microsoft.com",
"macrumors.com",
"google.com",
"samsung.com",
"twitter.com",
"hp.com",
"bhphotovideo.com",
"dell.com"
]
}

How to use it:

• objects.company.tech: Array of normalized technology identifiers (e.g., "omniture_adobe_analytics"). These are stable strings you can map to your own categories or rules.
• domain.categories: Useful if you also need IAB-aligned content categories to pair with tech for brand-safety or routing logic.
• domain.logo_url: Handy for UI enrichment in your CRM or internal tools.
• domain_registration_data: Dates and day counts; useful for scoring or heuristics (e.g., treat young domains differently).
• similar_domains: Expand enrichment or suggest alternatives when the tech array is sparse; also useful for clustering.

From tech identifiers to actions in your pipeline

Once you have the tech array, the most common workflow is mapping identifiers to your own categories and playing them into decisions. Below is a light-weight approach you can adapt.

Map identifiers to your categories

Create a data dictionary that maps known identifiers to general buckets your org understands (e.g., CMS, analytics, CDN, frameworks, ad tech, payments, CRM). The identifiers below are straight from the example; adjust your mapping to match your compliance or routing needs.

In production, store this mapping in a DB table or config file keyed by identifier. Your enrichment or decision engine can then evaluate any returned tech list into high-level traits (e.g., “Has enterprise CRM,” “Uses payment processor,” “Data tooling present”).

Act on the result

• Lead enrichment: On user signup, call the endpoint, detect “payments” or “CRM,” and nudge the right onboarding template.
• Ad inventory audit: For each publisher, detect the presence of ad-related tech and verify your allow/deny lists.
• Security and privacy reviews: Flag analytics or identity tools for consent checks and data governance.
• Integration readiness scoring: Combination of iPaaS, ETL, CRM indicates maturity—use it to prioritize sales engineering effort.

Operational guidelines: batching, caching, and error handling

Getting this into production usually hinges on predictable performance and cost control. The following practices are common across customers classifying domains at scale.

Batching strategy

• De-duplicate by registrable domain before sending requests. For paths within the same site, reuse the domain-level result unless you have a strong reason to inspect page-level variations.
• Batch by priority: user-initiated (foreground) requests first; backfill or refresh jobs as background batches.
• Honor rate limits: while specifics vary by plan, design concurrent workers with backoff and jitter. If you see 429 or timeouts, enqueue and retry with exponential backoff.

Caching and TTLs

• Cache by registrable domain (e.g., example.co.uk). A 7–30 day TTL is common; shorten TTL for high-change verticals.
• Persist raw JSON responses so you can re-map identifiers later without re-calling the API.
• Invalidate cache on critical signals (e.g., when your crawler sees major template changes).

Handling unknown or new domains

• If objects.company or tech is missing/empty, treat it as “no detected tech yet.” Fall back to light-weight heuristics or schedule a refresh.
• Combine with domain_registration_data to decide whether to retry sooner for very young domains.
• Use similar_domains to expand your crawl set or approximate stack traits when direct detection is sparse.

Retries and billing

• If the network fails or the target site is unreachable, retry later. Failed or unreachable calls are not billed.
• Log both request and response metadata (status, timing) to investigate spikes and tune concurrency.

Beyond tech: using categories and signals when needed

Although your primary field is objects.company.tech, the same family of Klazify endpoints returns categories aligned to IAB, logo URLs, and related domain signals. This is useful when your workflow needs both “what this site runs” and “what this site is about.”

• IAB categories: Gate where ads run, tailor content filters, or enforce brand-safety policies in tandem with tech detection.
• Logos: Enrich internal tools and CRMs for better operator experience.
• Similar domains: Create segment expansions, discover lookalikes, or target vertical cohorts.

For endpoint details and payload contracts, see the Documentation. You can also browse the broader capabilities on the MCP page, or head to klazify.com for an overview.

End-to-end example flow you can ship

1. On user signup, resolve their email domain or provided website to a canonical URL (https://domain.tld).
2. Check your cache. If stale or missing, POST to https://www.klazify.com/api/domain_tech with the domain URL.
3. Parse objects.company.tech. Map identifiers into your buckets (CMS, analytics, CDN, frameworks, ad tech, payments, CRM).
4. Attach derived traits to the account record in your data warehouse or CRM. Store raw JSON for reprocessing.
5. Trigger playbooks: assign the correct onboarding path, tag for integrations, or route to a sales segment.
6. Schedule periodic refreshes using your TTL policy and priority queues.

Common implementation questions

• How do I handle domains that return no tech? Treat it as “unknown/none detected.” Store the response, set a short retry window for young domains, and optionally use similar_domains for discovery.
• What’s the difference between tech detection and categorization? The tech endpoint returns technology identifiers (objects.company.tech). Categorization (via the main categorization endpoint family) returns IAB-aligned content categories and related domain signals. Use both when you need “what they run” plus “what they are.”
• Can I map tech identifiers to my own taxonomy? Yes. Keep a local mapping table keyed by identifier. Because identifiers are normalized strings, you can update your mapping without re-calling the API if you store raw responses.
• How should I batch at scale? De-duplicate by registrable domain, throttle concurrency with backoff, and separate foreground (user-triggered) from background refreshes. Cache results with a TTL appropriate for your use case.
• Are failed calls billed? Failed or unreachable calls are not billed.

Ready to build? Create a free account to get your API key, then call the tech endpoint and start enriching your pipeline. Register now, and keep the Documentation open as you wire it up.