Company Industry API: Get the Industry Tags

You need to attach reliable industry tags and company details to domains in your pipeline so you can enrich signups, segment leads, and control where ads run. By the end of this guide you’ll make a POST request that returns company industry tags and core firmographics for any domain, cache the results, and apply them to blocklists, enrichment, and reporting at scale.

Why this API is a strong fit for industry tagging

Industry tagging lives or dies on precision and coverage. The API behind Klazify analyzes page content and company signals so you can identify industries and operational context reliably, even on niche sites.

• Accurate industry detection using AI: Models analyze on-page content, not just metadata, making tags resilient to sparse or noisy pages and better at catching nuanced industry cues (for example, B2B “Compliance Software” versus broad “Software”).
• Global coverage: The classifier processes content in multiple languages, which matters when you need consistent industry tags for international sites.
• Real-time classification: Results reflect the current state of a site, which is useful when pages pivot or rebrand and you need tags that keep pace.
• IAB-aligned categories: Results map content to the IAB taxonomy, giving you industry-standard signals you can plug into ad tech, brand safety, and contextual controls.
• Simple REST integration: A single POST with a URL returns company data and tags. It’s straightforward to slot into enrichment jobs, event-driven functions, or pre-bid filters.
• Compliance and filtering workflows: The response gives you the tags and categories you need to build allow/deny logic and keep ads or users away from undesired content.

If you want a single source for company firmographics plus industry-level tags and content categories, Klazify keeps the integration surface small while covering these needs end-to-end.

What you’ll build

We’ll send a domain to the company endpoint, read back fields like name, location, employeesRange, revenue (range), raised, and tags, and store them in your data store keyed by domain. You’ll then use tags to drive decisions:

• Ad tech: Combine IAB categories with business tags to include or exclude placements.
• Signup enrichment: Add company size, location, and tags to CRM records for routing and scoring.
• Filtering: Enforce policy-based access or categorization downstream.

Endpoint you’ll use

This guide centers on the company enrichment endpoint:

• POST https://www.klazify.com/api/domain_company

Authentication: Bearer token in the Authorization header. Payload: a JSON object that includes the URL you want to classify and enrich.

Quickstart: one curl to get industry tags and company data

Copy and run this request. It posts a domain and returns the company data and tags you’ll use for enrichment and routing.

curl -sS -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"}'

Fields to expect in the response include:

• name: Company name derived from the domain.
• city, stateCode, countryCode: Location details suitable for territory routing.
• employeesRange: A size bucket you can map to small/medium/enterprise tiers.
• revenue: A range-style value for revenue. Use it directionally for scoring, not as an exact figure.
• raised: Capital raised to date, when available.
• tags: A list of business or industry tags you can use for segmentation and filtering.

Tip: Failed or unreachable calls are not billed. You can retry with backoff without cost leakage.

JavaScript example: parse the fields you’ll actually use

This Node.js snippet calls the same endpoint, extracts firmographics and industry tags, and shows where to store and how to branch logic for enrichment.

import fetch from "node-fetch";

// Minimal KV-style cache to avoid re-calling the API for the same eTLD+1.
const cache = new Map();

function getCacheKey(urlString) {
  try {
    const { hostname } = new URL(urlString);
    // For most cases, caching at the registrable domain (eTLD+1) level is sufficient.
    // In production, consider a public suffix list library to normalize this step.
    const parts = hostname.split(".");
    return parts.slice(-2).join(".");
  } catch {
    return urlString;
  }
}

async function fetchCompanyData(domainUrl) {
  const cacheKey = getCacheKey(domainUrl);
  if (cache.has(cacheKey)) {
    return { data: cache.get(cacheKey), cached: true };
  }

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

  // On network errors or 5xx, consider retry with exponential backoff.
  if (!res.ok) {
    // 4xx: validate input or throttle. 5xx: transient. Unknown: log and continue.
    throw new Error(`Klazify error: ${res.status} ${res.statusText}`);
  }

  const json = await res.json();

  // Normalize the subset of fields you need for downstream consumers.
  const company = json?.objects?.company || {};
  const result = {
    url: company.url || domainUrl,
    name: company.name || null,
    city: company.city || null,
    stateCode: company.stateCode || null,
    countryCode: company.countryCode || null,
    employeesRange: company.employeesRange || null,
    revenue: company.revenue || null, // A range-style value; treat as approximate.
    raised: company.raised || null,
    tags: Array.isArray(company.tags) ? company.tags : []
  };

  // Cache per eTLD+1 for a TTL window you choose (e.g., hours to days).
  cache.set(cacheKey, result);
  return { data: result, cached: false };
}

(async () => {
  const { data, cached } = await fetchCompanyData("https://cbsnews.com");

  // Example branching: route by company size and industry tags.
  const isEnterprise = data.employeesRange === "100K+";
  const isMedia = data.tags.includes("Media") || data.tags.includes("News");

  console.log({ cached, isEnterprise, isMedia, company: data });

  // Store in your DB keyed by eTLD+1 for reuse across signups and sessions.
})();

Operational notes:

• Cache by eTLD+1 so you don’t repeat calls for subdomains. Refresh on a TTL suitable for your business (for example, daily to weekly).
• If a response is missing a field (e.g., raised), keep nulls and let downstream logic be tolerant.
• For bulk enrichment, batch domains on your side and parallelize responsibly based on your plan’s guidance (see the Documentation for details).

How categories and industry mapping appear in the response

While you’ll often call the company endpoint for firmographics and tags, the categorization endpoint provides IAB-mapped categories you can combine with tags for more granular controls. Here is the official sample response you can use to understand how categories and company objects appear together:

{
    "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 these fields:

• domain.categories: IAB-aligned categories and confidence scores. Use to gate ad placements, content filtering, or contextual targeting. The IAB-632-596 code maps the category to an IAB path when present.
• objects.company: Firmographics, including name, location, employeesRange, revenue, raised, and tags. Use employeesRange and tags for lead scoring, routing, or sales territories.
• domain.logo_url: Fetch a logo for internal UIs or reporting.
• domain_registration_data: Useful for risk scoring or auditing (e.g., very new domains).
• similar_domains: Expand prospecting lists or find adjacent publishers for inventory planning.

From fields to decisions: a practical mapping

Handling batching, rate limits, caching, and unknowns

• Batching: Group domains on your side and call the API in controlled parallel batches. Tune concurrency based on your plan guidance in the Documentation.
• Rate limits: Respect the plan’s limits. Add a queue with jittered backoff on 429s or timeouts. Failed or unreachable calls are not billed, so safe retries with backoff are fine.
• Caching: Cache by eTLD+1 for a TTL you define (for example, 24 hours). Invalidate earlier if you detect material content changes.
• Unknown or new domains: If company data is sparse, store nulls and fall back to content categories from the categorize endpoint to keep your workflows unblocked.
• Idempotency and logging: Log request/response pairs by domain so you can trace enrichment decisions and avoid duplicate work.

Mapping to your internal taxonomy

Many teams already have a house taxonomy. You can keep Klazify’s IAB categories and tags as the source of truth and maintain a lookup table to your internal labels. A simple approach:

• Start with exact matches: If a tag equals one of your labels, map 1:1.
• Use IAB category paths: For example, if name is “/Internet & Telecom/Mobile & Wireless/Mobile Phones,” map the whole path or its parent to your category tree.
• Confidence thresholds: If multiple categories come back, prefer the highest confidence above a threshold; otherwise, store multiple labels.
• Version your mapping: Keep a versioned mapping file so you can reclassify historical data if you adjust rules.

If your taxonomy needs governance or multi-party review, consider centralizing these mappings with your model and prompt governance processes. For ideas, explore the MCP page.

Putting it all together in a pipeline

1) Normalize inputs

• Canonicalize URLs to eTLD+1 (e.g., extract example.com from login.example.com) before caching or storage.
• De-duplicate your domain list before enrichment runs.

2) Enrich with company data and tags

• POST to /api/domain_company with a JSON body of the URL.
• Persist name, city, stateCode, countryCode, employeesRange, revenue, raised, tags.

3) Add content categories as needed

• If you require IAB-aligned categories, also use the categorize endpoint to pull domain.categories + confidence.
• Combine tags and categories for downstream decisions.

4) Cache and refresh

• Cache each domain’s result and set a refresh schedule. Revalidate on demand when high-value leads or ad placements require the freshest data.

5) Apply business logic

• Lead enrichment: Route by employeesRange and countryCode; increase lead score for specific tags.
• Ad controls: Deny categories that conflict with your brand or compliance needs; include categories that match campaign targets.
• Security/IT: Flag newly registered domains (from domain_registration_data) for additional checks.

Operational details that save time

• Units and formats: Location fields use standard ISO-style country codes (e.g., US). employeesRange and revenue are ranges/buckets; treat them as categorical values, not precise numbers.
• Timestamps and timezones: Dates in domain_registration_data are in ISO date format (YYYY-MM-DD). Interpret days_ago and days_left as integers representing whole days.
• Resilience: If a call fails due to a transient error, implement backoff with jitter. Because unreachable/failed calls aren’t billed, you can retry without cost anxiety.
• Data modeling: Keep raw JSON alongside your normalized columns so you can reprocess without re-calling the API.
• SLA-sensitive paths: Pre-warm caches for critical partners or publishers ahead of peak events.

Pricing and getting started

The Starter plan is $39.99/mo and includes a 7-day trial. Failed or unreachable calls are not billed. You can create a free account and start testing immediately. Visit Klazify to learn more, and when you’re ready, use the link below to register and get your API key.

FAQ

• What’s the difference between the company and categorization endpoints? The company endpoint returns firmographics and tags (name, location, employeesRange, revenue as a range, raised, tags). The categorization endpoint returns IAB-aligned content categories with confidence, plus additional domain signals. Use both if you need firmographics and content context.
• How should I cache results? Cache by eTLD+1 with a TTL (for example, 24–168 hours). Invalidate early for high-value accounts or if you detect material site changes. Store both normalized fields and the raw JSON for reprocessing.
• What if the domain is new or sparse? Keep nulls in your model and rely on available tags or categories. You can also fall back to the categorize endpoint to extract IAB categories when firmographics are thin.
• Can I map multiple categories to my single internal label? Yes. Maintain a mapping table where multiple IAB paths or tags map to a single internal label. Use confidence thresholds to pick a primary, and keep the rest as secondary labels for analytics.
• How do I run this at scale? Batch domains, apply a concurrency limiter, respect plan guidance from the docs, and leverage caching to reduce duplicate calls. Log request/response pairs for traceability and cost control.

Ready to add industry tags and company data to your pipeline? Create your free account to get an API key and start calling the endpoint in minutes. Register. For full parameter and response details, see the Documentation. Learn more about governance options at MCP.