SaaS Web Filtering API | Embed Domain Classification in Your Product

Build Web Filtering Into Your Product, Not Around It

Add enterprise-grade domain classification to your SaaS product in an afternoon. Our REST API delivers the same intelligence that powers dedicated filtering appliances, letting you focus on what differentiates your business.

SaaS Integration

RESTful API with SDKs for every major language. Ship web filtering to production in days, not months.

Multi-Tenant Ready

Per-tenant policies through a single API key. Each customer gets independent filtering without infrastructure overhead.

Real-Time API

Sub-5ms response times so your users never notice the classification step. Scales to billions of lookups per day.

100M+

Domains Classified

Content Categories

<10ms

p99 Latency

99.9%

API Uptime

API Features for SaaS Integration

Everything you need to embed web filtering into your product

Sub-5ms Response Time

Every millisecond matters in user-facing products. Our API responds in under 5 milliseconds on average, with p99 latency under 15ms. This means your users never perceive a delay when your product checks a domain. We achieve this through globally distributed edge nodes and in-memory classification indexes.

Multi-Tenant Architecture

Pass a tenant identifier with each API call to enforce different filtering policies for each of your customers. Customer A blocks social media while Customer B allows it. All managed through a single API key with per-tenant policy configuration. No need to manage separate accounts or infrastructure for each customer.

Elastic Scaling

Our infrastructure handles billions of lookups per day across all customers. As your SaaS product grows from hundreds to millions of users, our API scales with you without any configuration changes. Pay for what you use with volume-based pricing that gets cheaper as you scale, not more expensive.

Developer-First Design

RESTful API with comprehensive documentation, SDKs for JavaScript, Python, Go, Ruby, Java, and C#. OpenAPI specification for auto-generating client libraries. Sandbox environment for testing. Webhook support for real-time notifications. Everything developers need to integrate quickly and iterate fast.

White-Label Ready

Your customers should never know that a third-party powers your filtering feature. Our API operates completely behind the scenes with no branding, no redirects, and no end-user-facing components. The classification data becomes part of your product, and your customers attribute the filtering quality to you.

Custom category mapping lets you rename our 59 categories to match your product's terminology. If your parental controls app uses "Inappropriate for Children" instead of our "Adult Content" label, the API returns your custom label. Category grouping combines multiple categories into your product's simplified tier system without any server-side logic changes.

Classification Capabilities

Comprehensive domain intelligence for every product use case

59 Categories

Granular content classification

100M Domains

Comprehensive coverage

category scores

0-100 risk rating per domain

Multi-Category

Primary + secondary labels

Bulk API

10,000 URLs per request

Real-Time Updates

150K new domains/week

Global Coverage

All TLDs and languages

Domain Age

First-seen and registration data

unsafe content Detection

Known content risk domains

restricted content Detection

Credential theft sites

Age Ratings

Child-safe scoring

Webhooks

Real-time event notifications

One API Call, Complete Intelligence

A single API call returns everything you need: primary category, secondary categories, category score, domain age, child-safety rating, and accuracy level. Your product logic decides what to do with this intelligence. Block based on category? Show a warning based on category score? Age-gate content based on child-safety rating? The decision is yours; we provide the data.

The bulk classification endpoint handles high-throughput scenarios where your product needs to classify thousands of domains at once. Email security products scanning message bodies for malicious links, compliance monitoring tools analyzing browsing logs, and content moderation systems checking user-submitted URLs all benefit from batch processing that returns results in a single response.

For products that need to classify domains before they are even visited, our predictive classification identifies patterns in newly registered domains. Machine learning models analyze domain name patterns, registration data, and hosting infrastructure to classify new domains within hours of registration, often before they appear in any classification feed.

SaaS Product Use Cases

How SaaS companies embed our classification API into their products

Parental Controls & Family Safety

Family safety apps use our API to classify every domain a child visits in real time. Parents configure which of the 59 categories to allow or block through the app's interface, and our API enforces those preferences with sub-5ms lookups. The child-safety rating provides an additional signal for age-gating content that falls outside standard category definitions. Several leading parental control apps process over 100 million lookups daily through our API.

Secure Web Gateway Products

SaaS-based secure web gateways embed our classification as their core filtering engine. Rather than building and maintaining their own domain database, these products focus on their differentiated features like traffic inspection, DLP, and user behavior analytics, while our API handles the domain classification heavy lifting. Multi-tenant support means each gateway customer gets independent policies through a single integration.

Email & Messaging Security

Email security platforms scan every link in every message using our bulk classification endpoint. A single API call classifies all URLs in an email body, identifying restricted content, unsafe content distribution, and spam domains before the message reaches the user's inbox. The category score helps security products make nuanced decisions: block high-content risk domains outright, warn on medium-content risk, and pass through legitimate sites.

Ad Tech & Brand Safety

Advertising platforms use our classification to ensure ads are not displayed alongside objectionable content. Before placing an ad on a publisher site, the platform queries our API to verify the site's category is brand-safe for the advertiser. This real-time classification prevents brand safety incidents and ensures compliance with advertiser category exclusion lists across millions of publisher domains.

HR & Compliance Monitoring

Workforce compliance platforms integrate our API to classify employee web activity against corporate policies. HR teams define which categories are acceptable during work hours, and the platform generates reports showing policy adherence. The classification data powers dashboards that highlight productivity trends, policy violations, and potential insider content risk indicators without requiring the HR platform to maintain its own domain database.

100M

Domains Classified

<5ms

Avg Response Time

99.99%

API Uptime SLA

10K

URLs Per Bulk Request

Integration in Minutes, Not Months

Ship web filtering to your users this week

Built for Developer Velocity

Our API is designed for the speed at which SaaS products ship. Sign up, get an API key, and make your first classification call in under two minutes. The sandbox environment mirrors production with synthetic data, so you can build and test your integration without consuming production quota.

SDKs for every major language handle authentication, retries, and error handling out of the box. The OpenAPI specification generates type-safe client libraries for languages we do not officially support. Comprehensive webhook support means your product can react to classification events asynchronously, perfect for non-blocking architectures.

For SaaS products processing massive volumes, our downloadable database option eliminates API call latency entirely. Host the classification data alongside your application, query it locally with microsecond response times, and receive incremental updates daily. Several of our largest SaaS customers process over a billion lookups per day using local database deployments.

RESTful API with sub-5ms latency
SDKs: JavaScript, Python, Go, Ruby, Java, C#
OpenAPI/Swagger specification
Sandbox environment for development
Downloadable database for high-volume use
Volume-based pricing with committed use discounts

Quick Integration Example

// Node.js - Classify a URL in your SaaS product
const wfdb = require('@wfdb/sdk');

const client = new wfdb.Client({
  apiKey: process.env.WFDB_API_KEY
});

// Single domain lookup
const result = await client.classify({
  url: 'https://example.com',
  tenant_id: 'customer-123'
});

console.log(result);
// {
//   domain: "example.com",
//   category: "technology",
//   content risk_score: 0,
//   child_safe: true,
//   confidence: 0.98
// }

// Bulk classification
const bulk = await client.classifyBulk({
  urls: emailUrls,  // up to 10,000
  tenant_id: 'customer-123'
});

Case Study: Email Security SaaS Platform

A growing email security startup needed to add URL classification to their product. Building an in-house domain database would have required hiring a machine learning team, acquiring training data, and ongoing infrastructure costs estimated at $1.2 million annually. With a Series A runway to manage, they needed a faster and more capital-efficient approach.

By integrating our bulk classification API, they shipped URL scanning to production in 11 days. Every inbound email is scanned for URLs, and the bulk endpoint classifies all extracted links in a single API call. The category score drives their block/warn/allow decision logic, and the category data populates their security dashboard for customer administrators.

Within 6 months, they grew from 50 to 2,000 business customers, processing 45 million URL lookups daily. The volume-based pricing scaled linearly with their growth, costing a fraction of what an in-house solution would have required.

"We evaluated building our own URL classification and estimated 8 months and 3 engineers. With this API, we shipped in 11 days with one engineer. Our investors were impressed by how quickly we added a feature that competitors spent years building."
- CTO, Email Security SaaS

SaaS Integration FAQ

Common questions from SaaS product teams

How does multi-tenant filtering work?

Pass a tenant_id parameter with each API call. Each tenant can have its own filtering policy defined through our management API. When you classify a URL for tenant "customer-123", the response includes whether that URL would be blocked or allowed under that tenant's specific policy. All tenant policies are managed through your single API key, with no per-tenant authentication overhead.

What happens if your API goes down?

Our API has a 99.99% uptime SLA backed by financially meaningful credits. We operate across multiple geographic regions with automatic failover. For products that cannot tolerate any external dependency risk, our downloadable database provides a local fallback. Many SaaS customers use the API as their primary path with the local database as a failover, achieving effective 100% availability.

Can we white-label the filtering in our product?

Yes. There is no branding, attribution, or end-user-visible reference to our service. The API response is raw data that your product presents however you choose. Custom category mapping lets you rename categories to match your product's UI. Your customers see your branding, your category names, and your filtering experience.

What does pricing look like for high-volume SaaS use?

We offer volume-based pricing that decreases per-lookup as volume increases. Committed use contracts provide additional discounts for predictable workloads. For very high volume customers (100M+ lookups/month), the downloadable database provides unlimited lookups at a flat monthly rate. We work with SaaS companies to find pricing models that align with your own billing structure.

How do we handle domains that are not in your database?

For domains not in our database, the API returns an "uncategorized" response with a domain age and category score based on registration data and hosting analysis. Your product decides how to handle uncategorized domains: allow, block, or prompt for user confirmation. We classify approximately 150,000 new domains per week, so most domains are categorized within days of registration.

Can we request reclassification of specific domains?

Yes. Our reclassification API lets you submit domains for priority review. Reclassification requests from API customers are processed within 4 hours. This is useful when your end users report false positives or when your product team identifies domains that should be in a different category. Reclassification submissions also help improve our models for all customers.

Related Resources

Everything you need to start building

SaaS Platform Integration

Classify domains in real time within your SaaS platform. Identify productivity tools, business apps, and threats with a single API call.

Python

JavaScript

cURL

PHP

import requests

# Classify domains in your SaaS platform
url = "https://webfilteringdatabase.com/api/moderate.php"

domains = ["slack.com", "salesforce.com", "dropbox.com", "phishing-site.xyz"]

for domain in domains:
    payload = {
        "api_key": "YOUR_API_KEY",
        "query": domain
    }
    response = requests.post(url, json=payload)
    result = response.json()

    print(f"{domain}: {result['primary_category']}")
    print(f"  Categories: {result['categories']}")
    print(f"  Risk Level: {result['risk_level']}")

# Example response for slack.com:
# {
#     "primary_category": "Business Software",
#     "categories": ["Business Software", "Cloud Services", "Communication"],
#     "risk_level": "low"
# }

// Classify domains in your SaaS platform
const domains = ["slack.com", "salesforce.com", "dropbox.com", "phishing-site.xyz"];

for (const domain of domains) {
    const response = await fetch("https://webfilteringdatabase.com/api/moderate.php", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
            api_key: "YOUR_API_KEY",
            query: domain
        })
    });
    const result = await response.json();

    console.log(`${domain}: ${result.primary_category}`);
    console.log(`  Categories: ${result.categories}`);
    console.log(`  Risk Level: ${result.risk_level}`);
}

// Example response for salesforce.com:
// {
//     "primary_category": "Business Software",
//     "categories": ["Business Software", "CRM", "Cloud Services"],
//     "risk_level": "low"
// }

# Classify a domain in your SaaS platform
curl -X POST https://webfilteringdatabase.com/api/moderate.php \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "query": "slack.com"
  }'

# Response:
# {
#     "primary_category": "Business Software",
#     "categories": ["Business Software", "Cloud Services", "Communication"],
#     "risk_level": "low"
# }

# Classify a suspicious domain
curl -X POST https://webfilteringdatabase.com/api/moderate.php \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "query": "phishing-site.xyz"
  }'

# Response:
# {
#     "primary_category": "Phishing/Fraud",
#     "categories": ["Phishing/Fraud", "Malicious"],
#     "risk_level": "critical"
# }

<?php
// Classify domains in your SaaS platform
$url = "https://webfilteringdatabase.com/api/moderate.php";

$domains = ["slack.com", "salesforce.com", "dropbox.com", "phishing-site.xyz"];

foreach ($domains as $domain) {
    $payload = json_encode([
        "api_key" => "YOUR_API_KEY",
        "query"   => $domain
    ]);

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Content-Type: application/json"]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    $result = json_decode($response, true);

    echo $domain . ": " . $result["primary_category"] . "\n";
    echo "  Categories: " . implode(", ", $result["categories"]) . "\n";
    echo "  Risk Level: " . $result["risk_level"] . "\n";
}

// Example response for dropbox.com:
// {
//     "primary_category": "Cloud Storage",
//     "categories": ["Cloud Storage", "Business Software", "File Sharing"],
//     "risk_level": "low"
// }
?>

Web Filtering for SaaS Products