Company Revenue API: Get Estimated Revenue

October 11, 2026
Company Revenue API: Get Estimated Revenue

You need to enrich a user signup or lead with a company’s estimated revenue so your scoring model can prioritize high-value accounts without manual research. By the end of this guide, you’ll call a single Klazify endpoint that returns company details (including revenue ranges) from a domain, parse the response, and plug the data into your pipeline with caching, retries, and taxonomy mapping covered.

Why Klazify is the right fit when you need estimated revenue from a domain

If your workflow starts with just a URL or email domain and ends with a scored, segmented lead or a filtered inventory source, Klazify compresses that entire path into one HTTP request. For revenue estimation and company enrichment specifically:

Illustration: Company Revenue API: Get Estimated Revenue
  • Accurate website categorization using AI: Klazify analyzes site content end-to-end to resolve the correct organization and identify the associated business context, improving match quality for enrichment fields like employeesRange, revenue, and tags.
  • Global coverage: Multi-language content handling helps resolve organizations behind domains across regions so revenue and size enrichment isn’t limited to English-language sources.
  • Real-time classification: Rather than relying on stale lists, Klazify fetches and analyzes content live, which is essential for companies that grow quickly or change branding/domains.
  • Industry-level categories via IAB: You can align revenue enrichment with standardized industry categories, improving ad safety, targeting, and analytics.
  • Simple API integration: A single POST with JSON input returns company fields you can use immediately in lead scoring, routing, CRM enrichment, and analytics.
  • Compliance and filtering: Combine revenue ranges with category signals to gate access, prioritize outreach, or segment audiences without building your own crawler or classifier.

If your use case is “estimate revenue and company size from a URL at scale,” Klazify’s domain-to-company enrichment provides the shortest path from input domain to actionable attributes.

What you’ll get back from the company enrichment endpoint

Use POST https://www.klazify.com/api/domain_company with a JSON payload containing the URL you want to enrich. Authentication is via a Bearer token. The response contains company fields you can pipe into your models immediately:

  • name
  • city
  • stateCode
  • countryCode
  • employeesRange
  • revenue
  • raised
  • tags

The revenue field represents an estimated range, not an exact accounting figure, so treat it as categorical or bucketed data in your scoring logic. Employees range, tags, and location further refine targeting and routing without requiring manual research.

Make your first request (curl)

The following example shows a single-domain POST with a JSON body. Replace YOUR_API_KEY with your token.

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

If the domain is reachable and can be resolved to an organization, you’ll receive a successful response with the company object. Failed or unreachable calls are not billed.

Parse the response in code

Here’s a minimal Python example that calls the same endpoint, reads the returned fields, and normalizes revenue for downstream use.

import os
import json
import requests
from decimal import Decimal

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

def fetch_company(domain_url: str) -> dict:
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
        "Accept": "application/json",
    }
    payload = {"url": domain_url}
    r = requests.post(API_URL, headers=headers, json=payload, timeout=20)
    r.raise_for_status()
    return r.json()

def to_revenue_bucket(revenue_value):
    # Revenue may be provided as an estimated range; treat it as a bucketed field in your system.
    # Many teams map ranges to low/medium/high buckets for scoring.
    # If the response is numeric, coerce it to a bucket; if it's a string range, map it directly.
    if revenue_value is None:
        return "unknown"
    if isinstance(revenue_value, (int, float)):
        if revenue_value < 10_000_000:
            return "under_10m"
        elif revenue_value < 100_000_000:
            return "10m_100m"
        elif revenue_value < 1_000_000_000:
            return "100m_1b"
        else:
            return "over_1b"
    if isinstance(revenue_value, str):
        return revenue_value.lower().replace(" ", "_")
    return "unknown"

def enrich_and_print(domain_url: str):
    data = fetch_company(domain_url)
    company = (data or {}).get("objects", {}).get("company", {})
    record = {
        "name": company.get("name"),
        "city": company.get("city"),
        "stateCode": company.get("stateCode"),
        "countryCode": company.get("countryCode"),
        "employeesRange": company.get("employeesRange"),
        "revenue_raw": company.get("revenue"),
        "revenue_bucket": to_revenue_bucket(company.get("revenue")),
        "raised": company.get("raised"),
        "tags": company.get("tags") or [],
        "source_url": company.get("url"),
    }
    print(json.dumps(record, indent=2))

if __name__ == "__main__":
    enrich_and_print("https://cbsnews.com")

In your own pipeline, you would:

  • Cache by registrable domain (e.g., example.co.uk) to avoid duplicate lookups and to control latency and cost.
  • Convert revenue to internal buckets for routing and scoring.
  • Store employeesRange and tags as arrays/strings for analytics and segmentation.
  • Retry with exponential backoff on transient network errors; do not spam retries if the domain is unreachable.

Official categorization response example (use these fields as-is)

Some integrations also fetch categorization, similar domains, and domain registration data for brand safety or targeting. The official example below shows the structure and the company object fields available for enrichment workflows. Use this exact payload for development and testing your parser:


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

Key fields to use:

  • objects.company.revenue: Use this to assign a revenue bucket for routing and prioritization.
  • objects.company.employeesRange: Secondary size signal; use to refine scoring.
  • objects.company.tags: Quick segmentation attributes for analytics and targeting.
  • domain.categories and IAB mapping: If you also need brand safety or contextual controls, map these to your policy engine.
  • similar_domains: Optionally expand targeting or deduplicate organizations operating multiple domains.

Additional JSON response examples you can test against

Use these complete JSON structures to validate parsers when your pipeline focuses on the company object. Values and fields match the official sample to ensure schema compatibility.

Company-only enrichment structure

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

Company enrichment structure (identical schema, used for parser testing)

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

How to use the returned fields in your pipeline

  • Lead scoring: Map revenue to a bucket and multiply score by a weight. EmployeesRange can serve as a tie-breaker when revenue is unknown.
  • Routing: Send high-revenue buckets to enterprise SDRs; medium to SMB teams. Use countryCode for geo routing.
  • Segmentation: Build cohorts from tags (e.g., “Mobile”, “B2C”) and employeesRange for marketing personalization.
  • Brand safety and analytics: If you also use categorization, block or allow by IAB categories and then prioritize by revenue.

Mapping revenue and categories to your internal taxonomy

Most teams translate external fields into internal enums. Keep your mapping in a dedicated config to avoid code changes when you update ranges or category policies.

  • Revenue mapping: Treat revenue as categorical. If the endpoint returns a range value, map the raw value directly to your internal range IDs. If it returns a numeric estimate, coerce to your nearest bucket.
  • Employees range: Use consistent company-size tiers (e.g., 1–10, 11–50, 51–200, 201–1K, 1K–10K, 10K+).
  • IAB mapping: Store the returned path and codes (e.g., IAB-632-596) and map to your content policy rules.

Caching, batching strategy, and handling unknown/new domains

For throughput and cost control, make the following operational choices:

  • Cache by registrable domain: Cache hits for 7–30 days depending on how dynamic your enrichment needs are. Evict earlier if a domain’s organization is likely to change.
  • Deduplicate before requests: Normalize inputs (lowercase, strip scheme, resolve punycode) and dedupe to reduce calls.
  • Rate limiting: If your job spikes traffic, implement client-side backoff and queueing. For specific plan details, see the Documentation.
  • Unknown or brand-new domains: If no company object is returned, queue a retry with a longer delay. Fall back to the domain categorization endpoint for context when enrichment is unavailable.
  • Timeouts and retries: Use conservative timeouts (e.g., 15–20s) and retry idempotently with jitter. Do not retry indefinitely; log and move on to keep pipelines flowing.

How this fits common workflows

  • CRM and lead enrichment: On form submit, call the domain_company endpoint, map revenue to your score, and write the attributes to your CRM. Cache results to avoid re-enriching the same domain.
  • Ad tech and brand safety: Classify inventory sources with categories and IAB codes; enrich the advertiser’s or publisher’s domain to estimate scale via revenue and employeesRange before accepting or prioritizing deals.
  • Content filtering: Combine IAB categories with revenue and size to weight decisions for enterprise-controlled networks.
  • Analytics: Store revenue buckets and tags to group outcomes by company scale and industry for product-led growth dashboards.

End-to-end example: enrich, bucket, and store

You can structure your enrichment job as a three-step process:

  1. Normalize and dedupe a list of domains.
  2. Fetch company enrichment; backoff and retry transient failures; skip persistent failures and mark for later review.
  3. Map fields into your schema (revenue_bucket, employees_tier, tags[]) and persist to your data warehouse.

For test automation, validate your parser against the complete official example (categorization + company) and the company-only examples above. This ensures your code handles nested fields, arrays like tags/tech, and nullables like raised.

Operational notes you should know before shipping

  • Authentication: HTTP Bearer token in the Authorization header.
  • Payload: JSON with a url field. Use HTTPS and application/json content type.
  • Costs and failures: Failed or unreachable calls are not billed, which simplifies retry logic without surprise charges.
  • Pricing to start: The Starter plan is $39.99/mo with a 7-day trial. Begin integration, validate mappings, and measure coverage during the trial.
  • Monitoring: Track response times, success rate, and non-null enrichment rates (e.g., how often revenue or employeesRange is returned) to tune your cache TTL and retries.

Comparing which fields to use by use case

Use Case Must-Have Fields Nice-to-Have Fields Notes
Lead Scoring revenue, employeesRange tags, countryCode Bucket revenue; use employeesRange as a fallback.
Routing/Assignment revenue, countryCode stateCode, employeesRange Route high buckets to enterprise; route by geo.
Brand Safety IAB category path tags Use categories to allow/block; enrich for context.
Analytics/Segmentation revenue, employeesRange tags Roll up by bucket and region for dashboards.

Reference JSON you can safely rely on

Keep this official example in your test fixtures to validate schema changes in your integration whenever you update dependencies or deploy parser changes.


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

Troubleshooting and data hygiene

  • Normalization: Always lowercase domains and strip schemes and paths. Use public suffix parsing to extract the registrable domain.
  • Ambiguous domains: Some domains host multiple brands. Cache cautiously and consider re-checking high-value records periodically.
  • Nullables: Fields like raised can be null. Don’t fail the pipeline if a field is missing—store defaults and move on.
  • Time-based drift: Re-check large or strategic accounts periodically to detect revenue or size changes.

Where to go next

Deploy your first integration on the Starter plan ($39.99/mo) with a 7-day trial. Begin by setting up an API key and making a single POST request, then wire the response into your CRM or scoring model. For implementation details, see the Documentation and, if your organization manages policy centrally, review MCP to keep mappings consistent across teams.

FAQ

Does the API return an exact revenue figure?
Treat revenue as an estimated range for operational use. Map it into your internal buckets for scoring and routing.

How should I cache results?
Cache by registrable domain for 7–30 days based on your tolerance for staleness and how quickly your segmenting decisions need to react to changes.

What happens if the domain is unreachable?
The call won’t be billed. Implement a limited retry with backoff and log for later review.

Can I align enrichment with IAB categories?
Yes. Use the categorization fields and IAB paths to add brand safety layers before or after enrichment.

How do I start testing?
Create an account, generate an API key, and run the POST example above. Validate your parser against the official JSON in this guide.

Ready to enrich signups with revenue and company details from a single domain lookup? Start your 7-day trial and get your API key here: Register. For full reference and advanced options, see the Documentation and explore centralized policy control with MCP.

Ready to use Klazify?

Start classifying websites, enriching company data, and exploring web intelligence.

Get Started Free