Company Funding API: Get the Funding Raised

October 13, 2026
Company Funding API: Get the Funding Raised

You need to enrich domains in your product or data pipeline with reliable company funding signals, so you can prioritize sales outreach, score signups, or audit partners by how much capital they’ve raised. By the end of this guide, you’ll call a single endpoint to retrieve a company’s raised amount (plus location, size, revenue and tags), parse the response, and wire it into a workflow that scales with caching, batching, and fallback behavior for unknown domains.

Why Klazify is the best fit for extracting funding signals from domains

Funding data is most useful when it’s tied to the right company and context. Klazify starts at a URL or domain and applies machine learning to analyze site content and metadata, returning standardized company objects, categories mapped to IAB taxonomy, and business tags. This matters for funding enrichment because you can:

Illustration: Company Funding API: Get the Funding Raised
  • Accurately determine the company behind a domain using AI that reads full website content, not just whois or sparse metadata, reducing false positives when fetching “raised.”
  • Cover global sites and multiple languages so you can enrich signups from any market without custom scrapers.
  • Get real-time classification and company updates so “raised” and other fields reflect recent changes instead of stale snapshots.
  • Map results to the IAB taxonomy for industry-level context, helpful when segmenting funded companies by sector.
  • Integrate quickly through a straightforward REST API that returns a consistent company object from a URL or domain.
  • Strengthen compliance and filtering by combining “raised” with category signals (e.g., exclude domains outside your ICP when allocating SDR time).

Compared to generic data sources that only expose static firmographics, Klazify couples funding-related fields like “raised” with real content-derived categories and tags. That combination lets you build precise, scalable automations: for example, route leads with raised > 0 and tags including “B2B” to a dedicated enterprise nurture flow, while deprioritizing others.

What you’ll build: a funding-aware enrichment step you can ship

We’ll use the company-from-domain endpoint to:

  • Send a domain and receive a normalized company object containing raised, revenue, employeesRange, location, and tags.
  • Cache results by domain to control latency and cost.
  • Implement a fallback for unknown or new domains (e.g., queue for later recheck, or call categorization for context while raised is null).
  • Map categories and tags to your internal taxonomy for scoring and routing.

To get started, create a free account here: Register. You can also browse the Documentation and read more on klazify.com.

Endpoint you’ll use

For company data tied to a URL, including “raised,” call the company-from-domain endpoint:

  • Method: POST
  • URL: https://www.klazify.com/api/domain_company
  • Auth: Bearer token
  • Body: JSON with a url field

In practice, you’ll pass the domain or homepage URL your user provided (e.g., at signup) or that you observed in traffic logs (for analytics/security use cases). Results include company.name, city, stateCode, countryCode, employeesRange, revenue, raised, and tags. The “raised” field is the key to funding enrichment. If the company cannot be resolved or funding data is not available, “raised” may be null.

Copy-paste cURL you can run

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

Notes:

  • Replace YOUR_API_KEY with your token from the dashboard after you Register.
  • Failed or unreachable calls are not billed.
  • For batch workflows, serialize calls or run them concurrently with backoff if you hit throttling. More on batching and caching below.

Official JSON example and how to use it

Here is the official example response format you will interact with when enriching a domain. Use it to understand where “raised,” “revenue,” “employeesRange,” and “tags” live in the response object. Do not modify these values; your actual responses will vary by domain.


{
    "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 for a funding-aware workflow:

  • objects.company.raised: funding raised. Treat null as “unknown” and apply a fallback (e.g., route to standard nurture instead of VIP).
  • objects.company.revenue: can be used alongside raised to refine lead scoring. In your data model, handle it as a numeric value or a range depending on the response.
  • objects.company.employeesRange: segment by size (e.g., SMB vs enterprise) when allocating SDRs.
  • objects.company.tags: fast heuristics to detect B2B/B2C or verticals; power routing and ICP checks.
  • domain.categories and IAB-632-596: map to your internal taxonomy or ad controls for context or brand safety.
  • domain.logo_url: helpful for UI enrichment in admin tools or CRMs.
  • domain_registration_data: optional signals for trust or maturity checks.

End-to-end example in Python

This snippet posts a domain, extracts “raised,” and shows how to guard against nulls while keeping a simple cache to reduce repeated lookups.

import os
import json
import time
import hashlib
import requests

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

# Very simple in-memory cache for demo purposes.
CACHE = {}
CACHE_TTL_SECONDS = 24 * 3600  # adjust per your freshness needs

def cache_key(domain_url: str) -> str:
    return hashlib.sha256(domain_url.encode("utf-8")).hexdigest()

def get_company_from_domain(domain_url: str) -> dict:
    key = cache_key(domain_url)
    now = time.time()

    # Cache check
    if key in CACHE:
        item = CACHE[key]
        if now - item["ts"] < CACHE_TTL_SECONDS:
            return item["data"]

    # API call
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    payload = {"url": domain_url}
    resp = requests.post(ENDPOINT, headers=headers, json=payload, timeout=15)

    # Graceful handling: do not assume success; non-billable if unreachable.
    try:
        data = resp.json()
    except Exception:
        data = {"success": False, "error": "invalid_json"}

    # Cache result even if partial, to avoid hot-looping on unknowns.
    CACHE[key] = {"ts": now, "data": data}
    return data

def funding_enrichment(domain_url: str) -> dict:
    data = get_company_from_domain(domain_url)
    company = (data or {}).get("objects", {}).get("company", {}) if isinstance(data, dict) else {}

    raised = company.get("raised")
    revenue = company.get("revenue")
    employees = company.get("employeesRange")
    tags = company.get("tags", [])
    name = company.get("name")

    # Routing example:
    # - VIP if raised is a known positive number
    # - Otherwise standard route
    route = "standard"
    try:
        if raised is not None and float(raised) > 0:
            route = "vip-funded"
    except Exception:
        pass

    return {
        "domain": domain_url,
        "company_name": name,
        "raised": raised,          # may be null
        "revenue": revenue,        # number or range depending on the response
        "employeesRange": employees,
        "tags": tags,
        "route": route
    }

if __name__ == "__main__":
    result = funding_enrichment("https://cbsnews.com")
    print(json.dumps(result, indent=2))

Integrate the output into your CRM, CDP, or data warehouse. Persist the full raw response for auditability and for future reprocessing when your scoring logic changes.

How to act on the results in common scenarios

  • Enriching a signup: When a user provides an email or domain, call the endpoint, and store raised, employeesRange, revenue, and tags on the account. Route “vip-funded” to an enterprise onboarding track; otherwise keep standard onboarding.
  • Lead scoring at scale: Batch-enrich your leads’ websites overnight. Use raised and employeesRange as primary signals, and tags/categories for vertical alignment. Cache to minimize re-pulls.
  • Auditing partners or placements: When reviewing where ads run or who you integrate with, use categories and tags for brand safety and sector fit; use raised to prioritize strategic partners.

Field overview for funding enrichment

Field Purpose Example usage
objects.company.name Company identity Normalize CRM account names and deduplicate.
objects.company.raised Funding signal Prioritize or segment funded accounts; trigger enterprise flows.
objects.company.revenue Commercial signal Complement raised with revenue to refine lead scores.
objects.company.employeesRange Company size Route to SMB or enterprise teams; capacity planning.
objects.company.city/stateCode/countryCode Geo routing and compliance Assign regional owners; respect market boundaries.
objects.company.tags Context & ICP checks Detect B2B/B2C or verticals; align messaging and offers.
domain.categories (IAB) Industry taxonomy Map to your internal categories; power ad and content filters.
domain.logo_url UI/branding Display in admin and CRM views.

Operational guidance: batching, caching, retries, and mapping

Batching at scale

For large backfills (e.g., nightly CRM enrichment), run worker pools that read domains from a queue and call the API concurrently. If you receive throttling signals, implement exponential backoff and jitter. Keep idempotency by deduping domains within a given window.

Caching

  • Cache by normalized domain (e.g., lowercase, strip protocol and trailing slash) to avoid repeat calls.
  • Select a TTL that matches your freshness needs. Funding and company size change less frequently than content categories, so you can often cache for longer.
  • On-demand refresh: provide a manual refresh in admin tools for critical accounts.

Handling unknown or new domains

  • If objects.company is missing or raised is null, treat this as “unknown funding” rather than “unfunded.”
  • Queue a retry later; new or low-signal domains may be enriched as more data becomes available.
  • Optionally, call the categorization endpoint for immediate context while you wait:
    • URL: https://www.klazify.com/api/categorize
    • Use returned IAB categories and tags to route or filter until funding is known.

Mapping to your taxonomy

  • Use domain.categories.name and any provided IAB fields (e.g., IAB-632-596 in the example) to align results to your internal schema. Maintain a mapping table that links IAB categories to your own labels.
  • Combine tags and categories for robust classification: tags handle business models (e.g., B2C), while IAB covers industry context.

Error handling and observability

  • Treat network failures as retryable; schedule retries with backoff. Failed or unreachable calls are not billed.
  • Log request IDs and store raw responses for auditing and reprocessing.
  • Create alerts for unusually high null rates in raised so you can investigate upstream changes or data gaps.

Latency and pipeline design

  • Perform enrichment asynchronously from your user path when possible. For signups, collect the domain, enqueue the enrichment, and update the account record once the response arrives.
  • For real-time decisions (e.g., gating a feature), rely on cached results and refresh in the background to avoid user-facing latency.

Security, compliance, and cost controls

  • Store and transmit the API key securely; do not expose it to client-side code. Rotate regularly per your internal policy.
  • Scope access to raw responses on a need-to-know basis; derived signals (like “is_funded”) can be shared more widely.
  • Use caching and de-duplication to control request volume. Monitor usage in your dashboard on klazify.com.
  • The Starter plan is $39.99/mo with a 7-day trial; ideal to build and test your integration before scaling.

Putting it all together: a practical flow

  1. Collect a domain at signup or from your data source.
  2. Normalize the domain and check your cache.
  3. If missing or stale, POST to https://www.klazify.com/api/domain_company with Authorization: Bearer YOUR_API_KEY and {"url":"https://example.com"}.
  4. Parse objects.company.raised. If present and positive, mark account as funded; else mark as unknown_funding.
  5. Also store employeesRange, revenue, tags, and categories for routing and analytics.
  6. Persist the raw JSON response for future audits and recalculations.
  7. Recompute lead score and push updates to your CRM/CDP.
  8. Schedule periodic refreshes for high-priority accounts or when signals are stale.

JavaScript variant (Node.js) if you prefer

import fetch from "node-fetch";

const API_KEY = process.env.KLAZIFY_API_KEY || "YOUR_API_KEY";
const ENDPOINT = "https://www.klazify.com/api/domain_company";

async function getFunding(domainUrl) {
  const resp = await fetch(ENDPOINT, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ url: domainUrl })
  });

  let data = null;
  try {
    data = await resp.json();
  } catch (e) {
    return { success: false, error: "invalid_json" };
  }

  const company = data?.objects?.company || {};
  const raised = company.raised ?? null;

  return {
    success: true,
    domain: domainUrl,
    company_name: company.name || null,
    raised,
    employeesRange: company.employeesRange || null,
    revenue: company.revenue ?? null,
    tags: company.tags || []
  };
}

(async () => {
  const enriched = await getFunding("https://cbsnews.com");
  console.log(enriched);
})();

Testing and QA tips

  • Use known domains to validate parsing and routing logic. Confirm behavior when raised is null.
  • Simulate network errors and verify retries don’t create duplicate CRM updates.
  • Unit test your taxonomy mapping against a small, curated list of domains covering different IAB categories.
  • Backfill in batches with dry-run mode that logs changes without writing to production systems.

Governance and data lifecycle

  • Define SLAs for how fresh funding data must be for decision-making (e.g., refresh quarterly for strategic accounts).
  • Annotate records with the fetch timestamp and any transformations applied (e.g., normalization, scoring thresholds).
  • Maintain a changelog for mapping rules so downstream teams understand score shifts when you update mappings.

FAQ

  • What if “raised” is null?

    Treat it as “unknown funding,” not unfunded. Keep the account in a standard route, and schedule a refresh. Use tags and categories for interim prioritization.

  • How should I cache results?

    Cache by normalized domain with a TTL aligned to your freshness needs. Funding and company size change relatively infrequently; categories may change faster.

  • Can I do batch enrichment?

    Yes. Run concurrent workers with backoff on throttling, dedupe domains, and write idempotent updates to your CRM/CDP. Cache aggressively to minimize repeat calls.

  • Which fields are most useful for lead scoring?

    Combine raised, employeesRange, revenue, tags, and IAB categories. Weight raised and employeesRange highest for prioritization, and use categories/tags for ICP fit.

  • How do I map IAB categories to my own taxonomy?

    Keep a mapping table keyed by IAB category names or codes (e.g., those shown in the response). Update the table without changing your core enrichment code.

Ready to add funding enrichment to your stack? Start building with a free trial today: Register. Explore the Documentation and check out MCP for more on managing your integration.

Ready to use Klazify?

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

Get Started Free