How to Get the Industry Tags

Your team needs reliable industry tags for domains so you can enrich signups, segment accounts, or block certain categories in real time. By the end of this guide, you will plug Klazify’s domain_company endpoint into your pipeline to fetch a company’s industry tags (plus location, employee range, revenue range, and funding), cache the results per domain, and map them to your internal taxonomy with confidence.

Why Klazify fits industry tagging for pipelines

Industry tags are useful only if they arrive quickly, match real content, and can be integrated into your decisioning. Klazify is built to classify and enrich domains from live website content and return actionable tags for each company.

• Accurate Website Categorization Using AI: Klazify analyzes on-site content rather than relying solely on metadata. That’s critical when you need precise business tags like “E-commerce,” “B2C,” or “Consumer Electronics” for enrichment or filtering.
• Global Coverage: Tags and IAB categories work across multiple languages, which helps when your signup flow accepts international domains or your ad inventory spans global sites.
• Real-Time Classification: Because the analysis is fresh, tags reflect current business focus, which is essential for brand safety checks or dynamic routing in your CRM.
• Industry-Level Categories: Alongside business tags, Klazify maps content to IAB taxonomy, enabling direct use in ad tech and content filtering systems.
• Simple API Integration: A single REST call returns tags and core company fields. You can add one step to your enrichment job without redesigning your pipeline.
• Superior Compliance and Filtering: Industry tags plus IAB categories make it straightforward to whitelist, blacklist, or flag borderline content with consistent logic.

If you need to automatically label signups by industry, exclude certain categories from ad placements, or enrich accounts for lead routing, Klazify gives you the fields and structure you can ship with.

What you’ll get: tags and company context

To retrieve industry tags from a domain, use the domain_company endpoint. It returns:

• name, city, stateCode, countryCode
• employeesRange
• revenue (returned as a range, not an exact figure)
• raised (funding to date)
• tags (the business/industry tags you can route on)

These fields let you build simple and fast rules, for example:

• Block or review signups when tags include categories you can’t serve.
• Prioritize leads when employeesRange meets a threshold and tags match ICP.
• Segment ad placements by IAB categories and supplement with tags for added precision.

How to request industry tags

The following shows a copy-pasteable curl call using the domain_company endpoint. Replace YOUR_API_KEY with your token and the url field with the domain you need to enrich. Note: failed or unreachable calls are not billed.

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

Starter is $39.99/mo with a 7-day trial. You can create a free account here: Register. Learn more about endpoints in the Documentation and the MCP. You can also explore the product on klazify.com.

Official example response format and how to read it

Below is the official JSON example. It shows how Klazify structures company and domain data, including categories, logo_url, and company details (name, location, employeesRange, revenue, raised, tags, tech). Use this as a template for parsing responses and planning your schema.

{
"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"
]
}

Fields you’ll actually use in your pipeline:

• objects.company.tags: The business/industry tags you can match against your rules.
• objects.company.name, city, stateCode, countryCode: Basic firmographics for enrichment.
• objects.company.employeesRange: Use for ICP checks or routing thresholds.
• objects.company.revenue: For the domain_company endpoint, treat revenue as a range. Use it for tiering rather than exact valuations.
• domain.categories and IAB- codes: Useful to align with IAB standards for ad placement and brand safety.
• domain.logo_url: Handy for CRM or UI enrichment.

End-to-end example in Python

This script calls the same domain_company endpoint you saw in curl, extracts industry tags and core fields, and shows how you might normalize them for routing. It also demonstrates simple per-domain caching to avoid re-hitting the API for domains you’ve already classified.

import os
import time
import json
import hashlib
import requests

API_URL = "https://www.klazify.com/api/domain_company"
API_KEY = os.getenv("KLAZIFY_API_KEY", "YOUR_API_KEY")

CACHE_DIR = "./.klz_cache"
os.makedirs(CACHE_DIR, exist_ok=True)

def cache_path(domain: str) -> str:
return os.path.join(CACHE_DIR, hashlib.sha256(domain.encode()).hexdigest() + ".json")

def load_cache(domain: str, max_age_seconds: int = 7 * 24 * 3600):
p = cache_path(domain)
if not os.path.exists(p):
return None
try:
mtime = os.path.getmtime(p)
if time.time() - mtime > max_age_seconds:
return None
with open(p, "r", encoding="utf-8") as f:
return json.load(f)
except Exception:
return None

def save_cache(domain: str, data: dict):
with open(cache_path(domain), "w", encoding="utf-8") as f:
json.dump(data, f)

def fetch_company(domain: str) -> dict:
cached = load_cache(domain)
if cached:
return cached

headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
}
payload = {"url": domain}

resp = requests.post(API_URL, headers=headers, json=payload, timeout=20)
# Non-2xx responses can indicate unreachable or missing data; these calls are not billed.
if resp.status_code != 200:
raise RuntimeError(f"Klazify error {resp.status_code}: {resp.text}")

data = resp.json()
save_cache(domain, data)
return data

def extract_industry_fields(data: dict) -> dict:
company = (data.get("objects") or {}).get("company") or {}
# Tags are the key output for industry labeling
tags = company.get("tags") or []
# Revenue is a range (for domain_company). Treat it as categorical, not exact.
return {
"name": company.get("name"),
"city": company.get("city"),
"stateCode": company.get("stateCode"),
"countryCode": company.get("countryCode"),
"employeesRange": company.get("employeesRange"),
"revenueRange": company.get("revenue"), # interpret as a range
"raised": company.get("raised"),
"tags": tags,
}

def map_tags_to_icp(tags):
# Example: map Klazify business tags to your internal ICP labels
mapping = {
"E-commerce": "sector:ecommerce",
"Consumer Electronics": "vertical:electronics",
"Mobile": "channel:mobile",
"B2C": "model:b2c"
}
out = set()
for t in tags:
if t in mapping:
out.add(mapping[t])
return sorted(out)

if __name__ == "__main__":
domain = "https://cbsnews.com" # replace dynamically in your pipeline
data = fetch_company(domain)
fields = extract_industry_fields(data)
icp_labels = map_tags_to_icp(fields["tags"])

print("Company:", fields["name"])
print("Location:", fields["city"], fields["stateCode"], fields["countryCode"])
print("Employees:", fields["employeesRange"])
print("Revenue (range):", fields["revenueRange"])
print("Raised:", fields["raised"])
print("Tags:", ", ".join(fields["tags"]) or "(none)")
print("ICP Labels:", ", ".join(icp_labels) or "(none)")

Deciding between categories and tags

Klazify returns both IAB categories and business tags. Categories reflect content classification (useful for brand safety and ad placement), while tags describe the business profile (useful for enrichment and segmentation). Many stacks use both: enforce safety by IAB category, then refine targeting with tags.

Field family	Use cases	Examples	Action
domain.categories + IAB- codes	Brand safety, contextual targeting, content filtering	/Computers & Electronics/Consumer Electronics; IAB-632-596	Whitelist/blacklist categories, tune ad placement
objects.company.tags	Lead enrichment, ICP fit, routing, signup gating	E-commerce, Consumer Electronics, Mobile, B2C	Match to internal taxonomy, score accounts, block disallowed industries
Firmographics	Qualification, territory routing	employeesRange, revenue (range), location	Assign owners, tiers, or SLAs

Operational guidance: batching, caching, retries

Batching domains

If you need to enrich many domains, run them in controlled batches. Keep a job queue and parallelize within safe limits for your environment, checking HTTP status codes and pausing on unexpected spikes of non-2xx responses. Since failed or unreachable calls are not billed, you can retry these later without unexpected costs.

Caching results per domain

• Cache by normalized domain (e.g., lowercase, strip UTM and paths) to avoid duplicate lookups.
• Set a TTL aligned with how fast your catalog changes. Tag drift is typically slower than content churn; choose a TTL that balances freshness and cost.
• Invalidate cache on explicit user correction (e.g., when sales updates industry) or after soft failures.

Retries and error handling

• Retry on network timeouts and 5xx responses with exponential backoff.
• Handle empty or null fields gracefully. If tags are missing for a new domain, enqueue it for a delayed retry.
• Log response fragments you rely on (tags, IAB categories, employeesRange) for easy diagnostics.

Handling unknown or new domains

When a domain is too new or lacks content, the tags array may be limited or absent. Recommended approach:

• Mark the record as “unclassified” and store a retry timestamp.
• Enrich with fallback signals you may already have (user-provided industry, email domain context) until Klazify returns tags.
• Use domain.categories if available for interim decisions, especially for ad safety.

Turn tags into decisions

Once you ingest tags, write deterministic rules and keep them transparent for audits. Here are patterns you can implement quickly:

• Signup enrichment: Populate CRM fields (Industry, Subindustry, Go-to-market model) from tags and employeesRange.
• Lead routing: Route “E-commerce” + “B2C” to a specific queue; route “B2B SaaS” (if present in tags) to another.
• Brand safety: If domain.categories includes restricted IAB branches, block ad serving, regardless of tags.
• Account scoring: Boost score for target tags; reduce for out-of-scope tags. Use employeesRange for tiering.

Mapping tags to your internal taxonomy

Most teams maintain an internal set of industry labels. The simplest strategy is a one-to-many map from Klazify tags to internal codes. Maintain it in a versioned store so you can safely update mappings without redeploying services.

• Create a dictionary of tag → internal label(s).
• Use inclusive matching: if multiple tags resolve to one label, deduplicate.
• Audit regularly: record which tag triggered which label for every decision.

If you also use IAB categories, consider a combined key like “IAB branch + tag set” to achieve both brand safety and ICP relevance.

Putting it together: a minimal enrichment flow

1. Normalize input domain (lowercase, scheme, strip query/path as needed).
2. Check cache. If expired or missing, call POST https://www.klazify.com/api/domain_company with the domain in the JSON body.
3. Parse objects.company fields: name, location, employeesRange, revenue (range), raised, tags.
4. Optionally fetch or rely on existing categorize results for IAB mapping when you need ad safety or contextual placement logic.
5. Map tags to internal taxonomy and write results to your data store (CRM, CDP, warehouse).
6. Use deterministic rules to block, enrich, or prioritize.
7. Log and monitor tag distribution to spot drift or anomalies.

Performance, throughput, and monitoring

• Throughput: Run enrichment workers horizontally and control concurrency with a token bucket. Watch for non-2xx spikes.
• Latency: Cache common domains and warm the cache for known cohorts (e.g., daily signups from the last week) to reduce p95.
• Observability: Track timeouts, error codes, and the rate of empty tags to guide retry intervals and review content quality.
• Cost control: Cache effectively; coalesce duplicate requests; queue retries for off-peak windows. Failed or unreachable calls are not billed.

What to store in your warehouse

• domain (normalized), objects.company.name, city, stateCode, countryCode
• employeesRange, revenue (range), raised
• tags (array) and your mapped internal labels
• IAB categories and confidence (if you also call categorize)
• logo_url for UI/CRM convenience
• Fetch timestamp, source (Klazify), and response metadata for audits

Security and privacy

• Use Bearer tokens and store them in your secrets manager.
• Don’t log tokens; redact sensitive headers in request traces.
• Hash/cache keys by domain; avoid storing full URLs if not required.

Troubleshooting common edge cases

• Empty tags: Retry later; check if the site has thin or gated content. Fall back to categories if present.
• Redirect-heavy sites: Normalize to the final landing domain and cache under that canonical value.
• Multi-brand portals: Prefer page-level categorize for contextual actions and use domain_company tags for account-level enrichment.

Where to go next

For an overview of endpoints and field definitions, see the Documentation. To explore plans or create your token, visit klazify.com or start your 7-day trial on the Register page.

FAQ

• Which endpoint returns industry tags? The POST https://www.klazify.com/api/domain_company endpoint returns objects.company.tags along with company details.
• How should I interpret revenue? Use revenue as a range for tiering and routing, not as an exact financial statement.
• Can I rely only on tags for brand safety? Tags are great for business enrichment. For ad placement and safety, combine tags with IAB categories from the categorize output.
• What if the domain has no tags yet? Handle gracefully: mark as “unclassified,” retry later, and use any available categories as an interim signal. Unreachable calls are not billed.
• How do I map tags to my own taxonomy? Maintain a versioned dictionary (tag → internal label). Apply it during ingestion and store the resolved labels alongside the original tags for auditability.

Ready to fetch industry tags and enrich your pipeline? Create your account and get an API token now: Register. You can also review the API surface at klazify.com.