How to Get the Funding Raised

You need to enrich domains with company funding data so your pipeline can prioritize leads, flag high-growth prospects, and quickly answer: “How much has this company raised?” By the end of this guide, you’ll call a single API to retrieve the funding raised from a domain, parse the response, cache it safely, and plug it into your enrichment, brand safety, or analytics workflows.

Why Klazify is the Best Fit for Funding Enrichment From a Domain

When your team needs “funding raised” for a domain, two things matter: reliably finding the correct company behind the URL and returning structured business fields you can feed to downstream systems. Klazify’s domain intelligence does both, pairing accurate classification with company-level enrichment so you can compute lead scores, route sales, or segment ads using one API call.

• Accurate Website Categorization Using AI: Funding data makes more sense in context. Klazify analyzes page content (not just metadata) and maps it to IAB categories, so you can understand whether a domain is, for example, consumer electronics retail or news media while you also retrieve “raised.” This lets you factor industry context into your funding-based logic.
• Global Coverage: You’ll encounter domains in multiple languages and markets. Klazify processes international sites, helping you standardize enrichment for global signups and vendor lists.
• Real-Time Classification: Domains evolve. Klazify evaluates content fresh rather than relying solely on a static database, which helps your enrichment reflect current business scope when paired with funding data.
• Industry-Level Categories (IAB): The IAB taxonomy is widely used in ad tech and brand safety. You can join funding raised with standardized categories to power rules like “Only prioritize B2B SaaS leads above a funding threshold.”
• Simple API Integration: A developer-friendly REST API returns company data (including raised) from a URL in a single request. It’s easy to add to ingestion jobs and webhook handlers.
• Compliance and Filtering: If your use case includes gating partners or auditing placements, combine funding fields and IAB categories for allow/deny logic without brittle ad hoc rules.

Start using Klazify by visiting the homepage at https://www.klazify.com, then create a free account to test the endpoints in your environment.

What Data You’ll Use to Get “Funding Raised”

Klazify provides structured company data from a URL or domain via a JSON API. For funding enrichment, you’ll primarily use:

• name: The company’s official name matched to the domain.
• city, stateCode, countryCode: Location data to localize scoring or routing.
• employeesRange: Company size to complement funding-based prioritization.
• revenue: Reported revenue information to pair with funding.
• raised: The total funding raised. This is the focal field for this guide.
• tags: Business tags derived from site content to add context and filtering.

For context and brand safety, you can also use categorization (IAB mapping) from Klazify’s primary categorization endpoint. Pairing “raised” with categories lets you perform targeted actions like gating affiliates or tuning CPC bids by both company stage and industry segment.

Make Your First Funding Enrichment Call

This example shows a single POST request to retrieve company data, including “raised,” directly from a domain. Use your own API key and the domain you want to enrich. Failed or unreachable calls are not billed. The Starter plan is $39.99/mo with a 7-day trial so you can validate the integration first.

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

Implementation tips:

• Use Bearer authentication in the Authorization header.
• Send a JSON body with the url you want to enrich.
• Cache the response at the domain level to avoid redundant lookups.
• If “raised” is null or missing, treat it as “unknown” and leave room to backfill later.

Check the Documentation for complete payload details and supported fields. You can also explore the broader model capabilities in the MCP.

A Full JSON Response You’ll Encounter

The categorization endpoint’s official sample below shows how classification, company data, and related signals are returned together and how “raised” is presented inside the company object. Use this structure as a reference when parsing fields such as categories, name, employeesRange, revenue, raised, and tags.

{
    "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 fields for funding-based workflows:

• objects.company.raised: Use as the primary “funding raised” value. If null, treat it as unknown and optionally schedule a recrawl later.
• objects.company.revenue and employeesRange: Combine with raised to compute stage or growth proxies in your lead scoring model.
• objects.company.tags: Map to internal go-to-market segments (e.g., B2B/B2C, ecommerce), filtering which deals to route by funding level.
• domain.categories and IAB mapping: Use to segment by industry for budget allocation or brand-safety rules alongside funding thresholds.
• domain.logo_url and domain_registration_data: Useful for UI and supplemental signals; cache to reduce repeated lookups.

End-to-End Code: Parse Funding Raised in Python

This Python example calls the same company enrichment endpoint you used with curl, then extracts “raised” and supporting fields you can store in your CRM or data warehouse.

import os
import json
import requests
from datetime import datetime, timezone

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

def fetch_company_funding(domain_url: str) -> dict:
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    }
    payload = {"url": domain_url}
    resp = requests.post(ENDPOINT, headers=headers, data=json.dumps(payload), timeout=20)
    # Handle non-billed failures gracefully
    if not resp.ok:
        return {
            "domain_url": domain_url,
            "status": resp.status_code,
            "error": resp.text,
            "fetched_at": datetime.now(timezone.utc).isoformat()
        }
    data = resp.json()
    # Defensive parsing: company may be missing or partial
    company = (data.get("objects") or {}).get("company", {})
    result = {
        "domain_url": domain_url,
        "name": company.get("name"),
        "city": company.get("city"),
        "stateCode": company.get("stateCode"),
        "countryCode": company.get("countryCode"),
        "employeesRange": company.get("employeesRange"),
        "revenue": company.get("revenue"),
        "raised": company.get("raised"),
        "tags": company.get("tags") or [],
        "fetched_at": datetime.now(timezone.utc).isoformat()
    }
    return result

if __name__ == "__main__":
    domain = "https://cbsnews.com"
    enriched = fetch_company_funding(domain)
    print(json.dumps(enriched, indent=2))

Operational notes for production:

• Timeouts: Use a client timeout to avoid hung workers in batch jobs.
• Retries: Only retry idempotent failures with backoff to avoid traffic spikes. Failed or unreachable calls are not billed.
• Caching: Cache results keyed by registrable domain (e.g., example.com) with a reasonable TTL (e.g., days to weeks), and revalidate on demand when a downstream rule requires a fresh value.
• Unknowns: If raised is null, store a sentinel (e.g., None) and apply a default score path. Consider scheduling re-enrichment for high-value domains.

How to Act on “Funding Raised” in Your Pipeline

Once you have raised, tie it to your decision logic. Here are three common scenarios:

• Enriching Signups: On new-account creation, look up the domain. If raised is above your threshold and employeesRange shows mid-to-large size, route to enterprise SDRs with a high-priority SLA.
• Auditing Where Ads Run: If raised is unknown or below your criteria, keep the publisher in a lower budget group until more signals arrive. Use IAB categories to segment by content vertical alongside funding-based guardrails.
• Blocking a Category: For network filtering, combine IAB mappings with funding. For example, only allow certain business categories with known raised to pass through into a “trusted” segment.

Handling Scale: Batching, Rate Limits, and Caching

At higher volumes, you’ll likely process tens of thousands of domains from ads, CRM backfills, or telemetry. Consider:

• Batching: Group domains per job and parallelize requests with a worker pool sized to your infrastructure. Spread across multiple queues to avoid head-of-line blocking.
• Rate Limits: Respect API rate guidance from the Documentation. Use backoff when you see 429s and queue retries to smooth spikes.
• Caching: Store JSON responses per domain with a last-checked timestamp. Recheck only after a TTL expires or a downstream rule requires a refresh (e.g., before re-scoring a high-value account).
• Idempotent Storage: Upsert on domain key so reprocessing is safe. Keep an “unknowns” list for periodic re-enrichment.
• Observability: Record request latency and HTTP status. Log response size and parse errors for quick triage.

Dealing With Unknown or New Domains

Sometimes a domain returns limited data or “raised” is null. Plan for this:

• Fallback Logic: Persist null as “unknown.” Do not infer values. Let downstream models treat unknowns neutrally.
• Re-enrichment Schedule: Reattempt after a fixed interval, or on demand when a sales rep requests a check.
• First-Seen Timestamp: Capture when you first enriched the domain to track data freshness alongside caching TTLs.
• User Experience: If you surface data in a UI, display “Unknown” rather than leaving a blank field and allow manual override if needed.

Mapping Categories and Tags to Your Internal Taxonomy

If you maintain your own industry taxonomy, keep a small, explicit mapping table. Example approach:

• For IAB categories returned by categorization, map top-level or leaf nodes to your internal verticals. Store both the IAB code/name and your internal label.
• For tags, define deterministic rules (e.g., if tags contain “B2B” then internal_segment = “B2B”). Keep this mapping versioned and testable.
• Combine category + tags + funding: For example, only route to an enterprise team if internal_segment = “B2B” and raised meets your threshold.

You can learn more about Klazify’s capabilities and taxonomy coverage on the homepage: https://www.klazify.com.

Putting It All Together: A Working Path to “Funding Raised”

Implementation Steps

• Create a free account: Register (Starter is $39.99/mo with a 7-day trial).
• Call the company enrichment endpoint with the domain on signup, import, or crawl.
• Parse objects.company.raised and store alongside employeesRange, revenue, and tags.
• Cache results per domain with TTL and re-enrich unknowns on schedule.
• Join with categorization data (IAB) when you need guardrails or audience segmentation.
• Apply your routing or scoring rules using raised as a primary signal.

Practical Details That Save Time

• Authentication: Use Bearer YOUR_API_KEY in the Authorization header.
• Units and Formats: Treat raised and revenue as numeric or range-like fields returned by the API. Do not convert or assume currency without checking the response. Store raw values and a normalized representation if needed.
• Timestamps: When you store enrichment results, capture an ingestion timestamp in UTC (e.g., ISO 8601) so you can monitor freshness and enforce TTL refreshes.
• Error Handling: Distinguish transport errors (timeouts, 5xx) from empty or partial results. Failed or unreachable calls are not billed.

FAQ

• How do I get “funding raised” from a domain?

  Send a POST request with the domain URL to the company enrichment endpoint and parse objects.company.raised. Cache results and re-enrich on a schedule for unknowns.

• Is categorization required to use “raised”?

  No. You can use raised on its own. However, pairing funding with IAB categories helps with brand safety, routing, and audience targeting.

• What should I do if “raised” is null?

  Treat it as unknown. Keep your pipeline idempotent, store null, and optionally schedule a future refresh. Avoid guessing or inferring values.

• Can I use this in batch jobs?

  Yes. Use a worker pool, respect rate limits, and add domain-level caching. Handle retries with exponential backoff and track per-request latency.

• Are failed calls billed?

  Failed or unreachable calls are not billed.

Ready to enrich domains with funding data and ship your integration? Create your account with a 7-day trial: Register, then explore the Documentation and MCP to integrate Klazify into your pipeline.