How to Find Websites by Country, Technology, or Company Size

You need a fast way to discover websites by country, technology stack, or company size so you can build targeted lead lists, enforce content policies, or audit where your ads run. By the end of this guide you will query Klazify’s discovery API to return a ranked set of domains matching your filters, then plug those results into your enrichment and categorization flow.

Why Klazify is the best fit for country-, tech-, and size-based website discovery

When your goal is to find websites by country, technology usage, or headcount bands, you want precision and coverage at scale. Klazify’s models analyze full site content and associated signals, so the discovery set you extract is both relevant and actionable.

• Accurate website categorization using AI: Finding sites that use a certain technology or match a business profile is easier when the underlying classification is reliable. Klazify analyzes full content (not just metadata), which is vital when filtering, for example, mobile-focused properties under “/Internet & Telecom/Mobile & Wireless/Mobile Phones.”
• Global coverage: Country-based filtering depends on consistent detection across languages and regions. Klazify’s global reach lets you construct lists for a single market or multi-country rollout.
• Real-time classification: Discovery results are backed by up-to-date analysis. That helps when targeting fast-changing tech ecosystems, e.g., new payment or analytics stacks.
• Industry-level categories: Klazify maps to the IAB taxonomy, enabling ad tech and brand safety teams to audit and control inventory by standardized categories while still narrowing by country and company size.
• Simple API integration: The discovery endpoint accepts filters for country, technology, IAB-mapped category paths, and employee ranges, returning a list you can feed directly into your data pipeline.
• Compliance and filtering: If you must block or whitelist certain categories in specific countries (e.g., for regulatory or brand safety reasons), you can construct defensible, repeatable filters that reflect your policy.

Common scenarios you can ship this week

• Ad inventory audits: Pull the top N domains in target countries that match a given IAB category. Feed them into your QA workflow before campaigns go live.
• Lead generation and enrichment: Find domains that use specific technologies (e.g., a payment processor or marketing automation vendor) and filter by employees to match your ICP. Enrich selected domains with company and category data for your CRM.
• Content filtering and brand safety: Build allowlists and blocklists by country and category, then enforce them across proxies, public WiFi, or app inventory.

All of the above start with one discovery call and can be layered with categorization for deeper analysis.

How the discovery workflow fits into your data pipeline

You’ll use a two-step pattern:

1. Search with discovery: POST your filters (country, technology, category path, employee range) and ask for the top_n results. This counts as a single API call.
2. Optional enrichment per domain: For any candidates you want to analyze further, call the categorization endpoint to retrieve categories, company object details, logo, tech stack, and similar domains. Use these fields to power ads QA, CRM enrichment, or filtering.

Operationally, cache discovery results per filter combination for at least a few hours to avoid redundant calls during iterations. When moving to production, maintain a local store keyed by the normalized filter set (e.g., country=US|tech=stripe,salesforce|employees=51-200|category=/Internet & Telecom/Mobile & Wireless/Mobile Phones) along with a fetched_at timestamp.

Pricing starts with the Starter plan at $39.99/mo with a 7-day trial. Failed or unreachable calls are not billed. You can Register for free and test the discovery endpoint right away.

Discovery endpoint: filters and a working request

The discovery endpoint lets you ask Klazify’s database for the top N domains that match a set of filters. At a high level:

• HTTP method: POST
• Endpoint: https://www.klazify.com/api/discovery
• Authentication: Bearer token
• Body parameters: top_n plus filters for category, country, tech, and employees

curl example: find domains by country, technology, category, and size

curl -s -X POST https://www.klazify.com/api/discovery \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "top_n": 50,
    "filters": {
      "country": "US",
      "tech": ["stripe", "salesforce"],
      "employees": "51-200",
      "category": "/Internet & Telecom/Mobile & Wireless/Mobile Phones"
    }
  }'

This single call queries Klazify’s database for up to 50 US-based domains that use the listed technologies, are within the specified employee band, and are relevant to the selected IAB-aligned category. It counts as one API call.

Code sample: calling discovery from Python

The snippet below demonstrates how to POST to the discovery endpoint, handle timeouts, and print the JSON payload for processing in your pipeline. Keep a local cache keyed by your filter set so you only re-hit the endpoint when parameters change.

import os
import json
import time
import requests

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

payload = {
    "top_n": 50,
    "filters": {
        "country": "US",
        "tech": ["stripe", "salesforce"],
        "employees": "51-200",
        "category": "/Internet & Telecom/Mobile & Wireless/Mobile Phones"
    }
}

def post_with_retry(url, headers, json_body, retries=3, backoff=1.5, timeout=15):
    attempt = 0
    while True:
        try:
            resp = requests.post(url, headers=headers, json=json_body, timeout=timeout)
            # The API does not bill for failed or unreachable calls
            resp.raise_for_status()
            return resp
        except (requests.exceptions.RequestException) as e:
            attempt += 1
            if attempt > retries:
                raise
            time.sleep(backoff ** attempt)

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

response = post_with_retry(URL, headers, payload)
data = response.json()

# In practice, persist this JSON and iterate over it to push candidate domains into your pipeline.
print(json.dumps(data, indent=2))

Tip: If you need to enrich a subset of these results further (e.g., to fetch a company object, logo, or similar domains), call the categorization endpoint for each selected domain and store your enriched record alongside the discovery result.

Using the categorization payload to enrich discovered domains

Once you have a candidate domain list from discovery, enrich individual domains with the categorization endpoint to retrieve categories, company information, logo, detected tech stack, domain registration data, and similar domains. Below is the official example of a categorization response you can expect to work with after discovery. Use it to map categories to your internal taxonomy, extract tech presence, or segment by employeesRange.

{
    "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: Each item has a category path (name) and optional IAB mapping. Use these to:
  • Block or allow by path (e.g., “/Internet & Telecom/Mobile & Wireless/Mobile Phones”).
  • Map to your internal taxonomy using the provided IAB code string when present.
  • Apply thresholds with the confidence score.
• domain.logo_url: Store for UI or CRM enrichment.
• objects.company: Use the structured business data in your pipeline:
  • url/name/location: Enrich account records and deduplicate.
  • employeesRange: Segment by company size to match your ICP.
  • tags: Build audience segments or content rules.
  • tech: Cross-check technology usage discovered via discovery filters; confirm presence of specific tools like “salesforce” or “stripe.”
• domain_registration_data: Useful for risk checks (e.g., very new domains) or renewal monitoring in cybersecurity and brand safety contexts.
• similar_domains: Expand your list by exploring adjacent properties. Feed these back into discovery or categorize to validate fit.

Mapping IAB categories to your internal taxonomy

Discovery lets you filter by a category path. If your system uses internal names, create a mapping table keyed by the Klazify category path or IAB-mapped string from categorization responses. Here’s a simple example using real category values from the payload above:

Store this mapping in your data warehouse and join on the category path when processing categorization responses or when setting up discovery filters.

Operational details: batching, caching, rate limits, and unknowns

• Batching via top_n: Discovery returns the top N results as a single call. Start with smaller values while you iterate (e.g., 25–50) and increase as needed once your workflow is stable.
• Caching: Cache discovery results per unique filter set for a defined TTL (for example, 6–24 hours depending on your update needs). Also cache categorization payloads per domain, refreshing periodically or when your policy requires.
• Handling unknown or new domains: Discovery may return zero results for very narrow filters. Broaden filters incrementally (e.g., relax employees range or reduce tech constraints) and retry. In downstream steps, treat missing fields conservatively.
• Rate limits: Apply exponential backoff and retries for transient errors and timeouts. For detailed limits and best practices, review the Documentation.
• Idempotency and deduplication: Store a stable key for each discovered domain. Before calling categorization, check your cache to avoid repeated enrichment calls.
• Error handling: Because failed or unreachable calls are not billed, retry safely with caps to avoid accidental traffic spikes.

From discovery to action: examples you can automate

• Brand safety filtering:
  • Discovery filter: country=US, category="/Internet & Telecom/Mobile & Wireless/Mobile Phones".
  • Action: Build an allowlist for your mobile campaign, categorizing each domain and verifying confidence thresholds before activation.
• ICP-qualified lead list:
  • Discovery filter: country=US, tech=[“stripe”, “salesforce”], employees="51-200".
  • Action: For each domain, categorize to extract employeesRange, tags, and tech; push to CRM with the logo_url and location fields.
• Ad inventory QA:
  • Discovery filter: category path for your target vertical and a set of countries you operate in.
  • Action: Categorize each result to confirm IAB mapping and run a diff against your internal taxonomy table. Spot anomalies before trafficking.

Field-by-field tips for enriching discovered domains

• Categories and confidence:
  • Use the highest-confidence category for primary routing; store all categories to support nuanced policies.
  • If category confidence is borderline for sensitive use cases, require a second matching signal (e.g., specific tech in objects.company.tech) before approving.
• Technology detection:
  • Use objects.company.tech to validate the stack assumptions that drove your discovery filter.
  • When a key technology is missing, place the domain in a review queue or lower its score in your ranking logic.
• Company size and location:
  • employeesRange is string-based and ideal for routing leads and segmenting outreach.
  • Use countryCode/stateCode/city for geo-targeted campaigns or compliance routing.
• Similar domains:
  • Great for expansion loops. Feed similar_domains back into your discovery or categorization cycle and deduplicate aggressively.

Quality gates before you ship

• Schema safety: Treat discovery responses as externally owned JSON. Validate keys exist before accessing. Log unknown fields for analysis.
• Normalization: Lowercase and trim domain strings. Always store canonical URLs from objects.company.url when present.
• Idempotent writes: Use upserts in your warehouse keyed by domain. Keep the latest categorization plus a change history for audits.
• Metrics: Track discovery-to-categorization hit rates, average categories per domain, and proportion of results passing confidence thresholds. Use these to tune top_n and filter breadth.

Governance and access controls

Restrict your API key to your server-side environment and monitor request volume. Store raw JSON payloads for compliance and to reproduce decisions in audits. For data handling, consult your internal governance guidelines and Klazify’s MCP resources.

Putting it all together

With a single POST to discovery, you’ll get a targeted set of domains filtered by country, technology, category, and size. Cache the results, score them against your policy, and use the categorization endpoint to enrich final candidates for brand safety, analytics, or CRM activation. This division of labor keeps your pipeline efficient: discovery narrows the universe; categorization deepens context.

FAQ

• Does the discovery request count as multiple calls when I ask for many results?
  No. A discovery request counts as a single API call even when you request a higher top_n.
• How should I cache discovery results?
  Key your cache by the normalized filter set (country, tech array, employees range, category) and set a TTL aligned to how often you need fresh results.
• What if discovery returns no results for my filters?
  Broaden one constraint at a time (e.g., remove one technology or widen the employees range) and re-run. Log your filter history to measure sensitivity.
• How do I map categories to my taxonomy?
  Use the category path and, where present, the IAB mapping string from categorization responses. Maintain a table to translate to your internal groups.
• Are failed calls billed?
  Failed or unreachable calls are not billed.

Ready to try it? Create a free account and run your first filtered discovery in minutes. Register, then read the Documentation for implementation details you can paste straight into your stack.