Company Name API: Get a Company Name

You need to turn a raw domain into a clean, usable company name (and related business details) so you can enrich signups, normalize CRM records, or gate features by organization. By the end of this guide, you’ll be able to call Klazify’s company endpoint with a domain, reliably extract the company name and key attributes, and plug them into your pipeline at scale with caching and batching.

Why Klazify is the right fit when you just need the company name (and more)

When your workflow starts from a URL or email domain, accuracy and latency matter. Klazify analyzes live website content rather than static lists, returning a normalized company name alongside location, size, revenue range, and tags—all from the same request you already need for categorization. Here’s how that helps specifically with company-name enrichment:

• Accurate name resolution from the live site: Klazify’s content analysis looks beyond WHOIS or metadata, helping resolve the public-facing brand name the user expects to see in your product.
• Global coverage: Works across languages and regions so “name + city + country” can be captured together for reliable deduplication and routing.
• Real-time classification: If a site’s branding or structure changes, you’re not stuck with stale references in your CRM or signup flows.
• Industry-level categorization via IAB: If you need more than the name, you can attach IAB taxonomy categories for downstream segmentation and brand safety.
• Simple API integration: A single REST call returns the company’s name and related attributes; no separate identity service or scraping is required.
• Compliance and filtering: Combine the company name with IAB categories and logo URLs to power allow/deny lists, approval queues, and review workflows.

If your primary objective is to enrich a signup or unify accounts by company name, Klazify’s single-call enrichment prevents you from wiring multiple services together and keeps the interface predictable for engineering and data teams.

What we’re building: enrich a signup with company name and attributes

Use case: a user signs up with [email protected]. You want to capture the company name, size, geography, and a few descriptive tags for routing (SMB vs. Enterprise), territory assignment (country/state), and personalization (industry or tags). We’ll call the domain company endpoint, store the result, and cache it so subsequent signups from the same domain don’t hit your rate limits or latency targets.

Endpoint and authentication

We’ll use the company data endpoint to extract the company name and business attributes directly from a domain or URL.

• HTTP method: POST
• Endpoint: https://www.klazify.com/api/domain_company
• Authentication: Bearer token in Authorization header
• Body: JSON with a single “url” field

Note on billing: failed or unreachable calls are not billed.

cURL example (copy, paste, run)

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

This request sends a single URL and returns company information fields such as name, city, stateCode, countryCode, employeesRange, revenue (a range, not an exact figure), raised, and tags—ready for immediate enrichment.

Official example response and how to use it

Below is the official sample response format you’ll see when calling Klazify. Use the company object to extract the name and key enrichment fields, and the domain-level information if you’re also classifying content or fetching the logo.

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

• objects.company.name: The normalized company name you’ll store in your database and surface in your app.
• objects.company.city, stateCode, countryCode: Use for geographic routing, territory mapping, or compliance workflows.
• objects.company.employeesRange: Drive SMB vs. Enterprise logic or lead scoring tiers.
• objects.company.revenue and raised: Useful context for qualification and segmentation. Treat values as ranges when using the company endpoint for enrichment.
• objects.company.tags: High-level descriptors of the business. Great for lightweight categorization and search filters.
• domain.categories and IAB mapping: Attach industry categories to the account record for brand safety, analytics, or ad placement rules.
• domain.logo_url: Display a logo in your UI to increase trust and recognition.
• domain_registration_data: Optional metadata that can help fraud detection and risk scoring.
• similar_domains: A starting point for account mapping or competitive analysis.

Code example: enrich a signup in JavaScript (Node.js)

This example calls the same company endpoint with a domain from your signup flow, then extracts the company name and a few useful attributes. Add caching as described in the next section to minimize repeat lookups.

import fetch from "node-fetch";

async function getCompanyFromDomain(domainUrl) {
const resp = 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 })
});

if (!resp.ok) {
// Not billed if unreachable or failed; decide whether to retry or queue
throw new Error(`Klazify error: ${resp.status} ${resp.statusText}`);
}

const data = await resp.json();

// Defensive checks in case a domain is new or sparse
const company = data?.objects?.company || {};
const name = company.name || null;
const city = company.city || null;
const state = company.stateCode || null;
const country = company.countryCode || null;
const size = company.employeesRange || null;
const revenue = company.revenue || null;
const raised = company.raised || null;
const tags = Array.isArray(company.tags) ? company.tags : [];

// Optional: industry and logo from the domain section
const categories = Array.isArray(data?.domain?.categories) ? data.domain.categories : [];
const logoUrl = data?.domain?.logo_url || null;

return {
name,
city,
state,
country,
size,
revenue,
raised,
tags,
categories,
logoUrl
};
}

// Example usage
getCompanyFromDomain("https://cbsnews.com")
.then((res) => console.log("Company enrichment:", res))
.catch((err) => console.error(err));

Plugging into your pipeline: batching, caching, and fallbacks

Once you can retrieve a company name and attributes for a single domain, the next step is to integrate it efficiently at scale.

Batching and throughput

• Queue domains from signups, CRM backfills, log-derived hostnames, or email captures. Process them in workers to maintain consistent throughput.
• If your workflow generates the same domain multiple times (e.g., multiple signups from one company), deduplicate before calling the API.
• For bulk jobs, keep a rolling cache (explained below) to avoid repeat lookups within your chosen TTL.

Caching strategy

• Cache keys: the registrable domain (e.g., example.com). Normalize URLs before calling the API and before cache lookup.
• TTL guidance: company names and locations change infrequently. A 7–30 day TTL is typical for enrichment; use shorter TTLs if you also rely on categories that can shift.
• Upserts: treat each enrichment as an upsert in your DB so you retain history but keep the operational record current.

Handling unknown or new domains

• If the response lacks a company object or has minimal fields, place the domain in a retry queue with exponential backoff.
• Use a “pending enrichment” state in your user/account model to avoid blocking signups; fill in the company name asynchronously.
• If you cannot resolve a name after multiple attempts, fall back to a formatted domain string (e.g., “Example”) for UI display, while logging for review.

Mapping categories to your own taxonomy

Even if your immediate need is the company name, coupling the name with industry categories can unlock routing rules and brand safety policies. Klazify provides IAB taxonomy mapping in the categories array, which you can translate to your internal schema.

• Use domain.categories[].name for a readable path (e.g., “/Internet & Telecom/Mobile & Wireless/Mobile Phones”).
• Use any provided IAB mapping codes or labels (e.g., IAB-632-596) to connect to your internal taxonomy matrix.
• Store top-1 category plus up to N alternates above a minimum confidence threshold. The confidence field can help you set gates for automated decisions vs. review.

Field guide: what to store, where to use it

Error handling, SLAs, and operations

• Timeouts: set client timeouts to keep signup flows responsive. If the call times out, continue the flow and backfill asynchronously.
• Retries: retry transient network failures using exponential backoff. Remember that failed/unreachable calls are not billed.
• Idempotency: dedupe requests per domain before enqueuing to prevent unnecessary traffic and inconsistent states.
• Observability: log the request domain, status code, and whether you used cache vs. network. Attach the response’s success flag where available.
• Refresh cycles: schedule a periodic refresh (e.g., monthly) for high-value accounts to catch location or category changes.

End-to-end example: enrich a signup form

1. User enters work email.
2. Extract and normalize domain (lowercase, strip subdomains if appropriate).
3. Check cache for the domain. If hit, populate the company name immediately.
4. If miss, POST to https://www.klazify.com/api/domain_company with the domain’s homepage URL.
5. On success, store:
   • objects.company.name into your accounts table (company_name)
   • location fields (city, stateCode, countryCode) for routing
   • employeesRange and revenue for scoring
   • tags for UI facets, and categories for IAB mapping
   • domain.logo_url for your onboarding UI
6. Cache the result keyed by registrable domain with your chosen TTL.
7. If the call fails, continue the signup and queue a backfill job.

Policy-driven uses: blocking, enriching, and auditing

• Blocking or allowlisting: Combine objects.company.name with domain.categories to implement brand safety or content access policies. For example, allow a target industry and queue uncertain categories for review using the confidence score.
• Enrichment: Add names, size, and tags to CRM leads for routing and personalization in your product and messaging.
• Auditing: Attach the logo_url and IAB category snapshot to your ad placement or partner review records for later audits.

Pricing, plans, and getting started

You can start quickly and validate the enrichment flow without procurement delays. The Starter plan is $39.99/mo with a 7-day trial. Learn more on klazify.com, and go hands-on with the endpoints in the Documentation. For management and credentials, check out the MCP.

Kicking off your integration

Set up your API key, post a test domain, and wire the response into your data model for accounts. If you need to evaluate coverage against your domain corpus, use a batch job with caching and log outcomes for accuracy review. You can always revisit thresholds for assigning categories as you learn from production traffic.

• Create your account: Register
• Quickly test endpoints: Klazify homepage

FAQ

• Can I send multiple domains at once?
  Submit domains in parallel from a worker pool or queue, deduplicating per registrable domain. Keep a cache to avoid duplicate API calls across batches.
• What if a domain has little or no public info?
  You may receive partial fields or no company object. Place the domain in a retry queue and use a fallback display name derived from the domain until enrichment completes.
• How often should I refresh the company name and attributes?
  Names rarely change, but tags and categories can. Many teams refresh monthly for active accounts and quarterly for the rest, with a 7–30 day cache TTL for routine lookups.
• How do I map IAB categories to my internal taxonomy?
  Store the category name and IAB mapping fields from the response. Maintain a lookup table that maps IAB labels/codes to your internal segments and thresholds based on confidence.
• Are failed or unreachable API calls billed?
  No—failed or unreachable calls are not billed.

Ready to enrich your signups and records with reliable company names and attributes? Create your free account and start integrating today: Register. Explore more endpoints and parameters in the Documentation, and keep klazify.com handy as your single source for domain intelligence.