School Internet Filtering | Student Content Control for Education Networks

Why a Campus Firewall Alone No Longer Works

A school network stopped ending at the front gate years ago. Loaner laptops go home, lessons stream from living rooms, and an appliance in the server closet sees none of it. With more than 100 million domains sorted into 59 categories, staff can set rules that match a student's age without accidentally locking the library.

Learning Platform Hooks

One API call is all Canvas, Blackboard, Moodle or Google Classroom needs to start screening links.

CIPA and COPPA Coverage

Every category the statutes name is already classified, which keeps E-Rate paperwork uneventful.

Filtering From the Cloud

Every connection behaves the same, inside the building or well outside it, answering in under 10 ms.

100M+

Domains On File

Filtering Classes

<10ms

Typical Response

99.9%

Service Availability

Federal Rules, State Rules and Student Safety

Satisfy the mandates without turning the internet into a walled garden

E-Rate and CIPA

Any school or library drawing E-Rate funds has to put a technology protection measure in front of internet access. Every category the Children's Internet Protection Act names, obscene content, child pornography and material harmful to minors, is already covered in the classification set, so eligibility never becomes a question.

Protecting Under-13 Users

Products aimed at children under 13 sit inside the Children's Online Privacy Protection Act, which sets a high bar for consent. Domains known to harvest personal details from minors without it are flagged during classification, so an ed-tech platform can hold its COPPA posture without hand-auditing every outbound link.

FERPA and Student Records

FERPA treats a student's educational record as confidential, and browsing history slides into that definition faster than most people expect. Lookups are stateless by design: no student PII reaches our servers, nothing about an individual learner is retained, and each decision is made and then forgotten.

State Statutes Beyond CIPA

Plenty of states stack their own student safety legislation on top of the federal baseline, from SOPIPA in California to Education Law 2-d in New York. Because categories are assigned independently of policy, district IT can mix and match blocks until the configuration lines up with whichever statutes apply locally.

Policy Tiers That Grow With the Student

A five-year-old tapping through a phonics app and a senior sourcing an AP History paper have almost nothing in common as internet users. Splitting the 59 content categories across separate tiers lets one district serve both without either group getting the wrong experience.

Typical elementary settings shut off gaming, social platforms and anything still unclassified. By middle school, selected social networks often reopen so digital citizenship can actually be taught with live examples. High school and university tiers loosen further, holding the line only on unsafe and explicit material. Moving a device between tiers is a single API parameter.

Which Categories Actually Matter in a School

All 59 classes ship with the database; these are the ones education customers reach for first

Adult Content

Explicit and pornographic pages

Gambling

Casinos, sportsbooks, wagering

Violence & Weapons

Gore imagery, firearms retail

Unsafe Content

Scams and risky destinations

Gaming

Game portals and launchers

Social Media

Networks and chat apps

Streaming Media

On-demand audio and video

Shopping

Retail storefronts, auction sites

Drug & Alcohol

Alcohol, tobacco and narcotics

Proxy & VPN

Circumvention services

Education

Coursework and school sites (allow)

Research & Reference

Journals, encyclopedias, archives

Letting the Useful Material Through

Over-blocking does as much damage as under-blocking. A teacher who cannot open a reference page halfway through a lesson stops trusting the filter, and once trust goes the workarounds start. Classification looks at what a page actually contains rather than judging the whole domain at once, so a biology entry on Wikipedia passes while an unrelated forum thread hosted alongside it can still be pulled for review.

Vendors building education software increasingly run links through the API at publication time rather than at click time. A resource dropped into a Canvas module or a video shared in Google Classroom gets checked against the active policy before a single student opens it, which converts incident response into prevention.

Roughly 150,000 freshly classified domains join the set each week. New school sites, emerging ed-tech tools and brand-new registrations get typed within hours, so policies stay accurate with nobody maintaining a list by hand.

How Education Customers Put It To Work

Five deployment patterns we see repeatedly across districts, campuses and libraries

District-Wide Chromebook Fleets

A district pushes the lookup out to thousands of Chromebooks and tablets, and every URL a student opens resolves in under 5ms. Policy is set per grade band: the youngest classes work from a curated allowlist, seniors get wide access with explicit content blocked. When a lesson needs a category opened, the teacher does it themselves instead of filing a ticket with IT.

Screening Links Inside the LMS

One large learning platform runs every externally posted link through classification before it renders. Whether the URL arrives on a course page, in a discussion reply or inside an assignment upload, it gets typed first, and anything landing in unsafe or inappropriate territory is held back for the instructor to look at. Students never meet harmful content dressed in the LMS's trusted interface.

Keeping Research Open on Campus

Higher education cannot run the same rulebook as a middle school and should not try. A permissive university profile stops unsafe and illegal destinations only, leaving difficult but academically legitimate subject matter reachable. Faculty working on extremism, public health or offensive security get to their sources without setting off an alert every afternoon.

Take-Home Device Programs

When a school hands a laptop to a student, its duty of care leaves the building with the hardware. Because the lookup happens in the cloud, the network underneath stops mattering: a Chromebook on a home WiFi connection enforces exactly the profile it enforced in homeroom, and CIPA coverage stays unbroken across both.

Public and School Library Terminals

Libraries taking E-Rate money have to filter, and they also carry a professional commitment to intellectual freedom that pulls the other way. Separate profiles run on the children's machines and the adult terminals. With 59 distinct categories to work from, staff can shut off explicit content without sweeping up health information, LGBTQ+ resources or other protected speech alongside it.

100M

Domains In The Set

Distinct Classes

<5ms

Median Query Time

300K+

Fresh Classifications Each Week

Wiring It Into the Tools Schools Already Run

A single request is enough to add link screening to any learning platform

Nothing Exotic Required

The REST endpoint sits happily behind Canvas, Blackboard, Moodle, Google Classroom, Schoology, Brightspace or something built in-house. One call comes back with the domain category, a category score and a policy recommendation in under 5 milliseconds, which is comfortably below the threshold where anyone notices a filter is present.

Need to sweep an entire syllabus or resource library? Bulk endpoints classify thousands of URLs in one request. Webhooks fire the moment a student hits a blocked domain, giving staff visibility into patterns while no per-student browsing log is ever written.

Districts short on IT hours can skip the integration work entirely. Pre-built plugins exist for the popular platforms and browser management tools: install the Canvas LTI app or the Chrome extension, pick a policy in the dashboard, and filtering is live district-wide before the morning is out.

REST endpoint answering in under 5ms
Ready-made LTI apps for Canvas and Blackboard
Extensions for both Chrome and Edge
Batch endpoints for whole URL lists
Webhook callbacks as events happen

Python: Screening a Posted Link

import requests

# Type a link before it ever reaches the class
def check_url(url, grade_level):
    response = requests.get(
        "https://api.webfilteringservice.com/v1/check",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        params={
            "url": url,
            "policy": grade_level
        }
    )
    result = response.json()
    return result

# Example: a link dropped into a Canvas thread
result = check_url(
    "https://example.com/resource",
    grade_level="k-5"
)

if result["action"] == "block":
    notify_teacher(result["category"])
else:
    allow_link()

Field Notes: Retiring an Appliance Across 65 Schools

A suburban district with 42,000 students spread over 65 schools had reached the end of the road with its filtering appliance. The box could not see take-home devices at all, added noticeable delay whenever the network got busy, and demanded manual policy edits that had quietly grown into two full-time IT positions.

Moving the lookup into their Chromebook management platform closed the off-campus gap and made behaviour identical in both places. Latency fell from 200ms to under 5ms and the complaints about slow page loads stopped arriving. Automated daily database updates retired the manual URL review process outright.

"The old setup somehow generated complaints in both directions at once, too much blocked and still not enough. Now nobody mentions it at all. Our teachers spend their time teaching rather than filing tickets to get a science site unblocked."
- Technology Director, suburban K-12 district

Questions We Get From Schools

Short answers on compliance, devices, overrides and coverage

Is this enough on its own to satisfy CIPA?

It is. Domains are typed against every content category CIPA names, obscene material, child pornography and content harmful to minors included, which is precisely what the technology protection measure requirement asks for. Schools and libraries running the API keep their E-Rate eligibility, and compliance documentation plus audit reports are available whenever you need them.

What happens when a lesson needs a blocked category?

The teacher lifts it themselves from inside the LMS. Opening "health and medicine" for one biology period leaves the rest of the school untouched. Overrides expire on their own, land in the audit log for accountability, and can be configured to require an administrator's sign-off first if that is how your district prefers to operate.

Does any of this reach personal laptops and phones?

In BYOD settings the API pairs with DNS-based filtering and browser extensions, so policy applies the moment a device joins school WiFi or signs in to the LMS, whoever happens to own it. School-issued hardware taken home is covered by the same cloud lookup over any connection, with no VPN tunnel to configure or babysit.

Students always find a proxy. Do you keep up?

There is a dedicated "Proxy and VPN" category covering known VPN services, web proxies and anonymization tools of the kind that circulate around a school in an afternoon, and it is refreshed daily as new ones appear. Paired with DNS-level filtering it gives you two layers to get through instead of one, which is usually enough to make circumvention more trouble than it is worth.

What about a domain that was registered this morning?

The automated pipeline types new registrations within hours. Until that finishes, anything under 30 days old and still unclassified can be blocked outright or routed for review, and it is usually worth doing: very young domains carry a disproportionate share of restricted and unsafe content. It closes the window between a site going live and its classification landing.

How many separate policies can one district run?

As many as you like. Each request carries a policy parameter, so the number of tiers is unlimited, though most districts settle on three to five: elementary, middle school, high school, staff and guest. A tier is simply a statement of which of the 59 categories to block, allow or flag. Build them in the dashboard or drive them programmatically through the management API.

Keep Reading

More on filtering in education and how the API fits together

Content Safety Endpoint

Send a domain, get its category and risk level straight back. Quick enough to run inline while course material is still being published.

# Screening course-material domains
import requests

def check_domain(domain):
    response = requests.post(
        "https://webfilteringservice.com/api/moderate.php",
        json={
            "api_key": "YOUR_API_KEY",
            "query": domain
        }
    )
    return response.json()

# Run the reading list through it
domains = ["coursera.org", "zoom.us", "discord.com", "cheating-service.com"]
for domain in domains:
    result = check_domain(domain)
    print(f"{domain}: {result['primary_category']} (risk: {result['risk_level']})")

# Response:
# {
#   "primary_category": "Education",
#   "categories": ["Education", "E-Learning"],
#   "risk_level": "low"
# }

// Screening course-material domains
async function checkDomain(domain) {
    const response = await fetch(
        "https://webfilteringservice.com/api/moderate.php",
        {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({
                api_key: "YOUR_API_KEY",
                query: domain
            })
        }
    );
    return response.json();
}

// Run the reading list through it
const domains = ["coursera.org", "zoom.us", "discord.com", "cheating-service.com"];
for (const domain of domains) {
    const result = await checkDomain(domain);
    console.log(`${domain}: ${result.primary_category} (risk: ${result.risk_level})`);
}

# Screening course-material domains
curl -X POST https://webfilteringservice.com/api/moderate.php \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY",
    "query": "coursera.org"
  }'

# Response:
# {
#   "primary_category": "Education",
#   "categories": ["Education", "E-Learning"],
#   "risk_level": "low"
# }

// Screening course-material domains
function checkDomain($domain) {
    $ch = curl_init("https://webfilteringservice.com/api/moderate.php");
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["Content-Type: application/json"]);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
        "api_key" => "YOUR_API_KEY",
        "query" => $domain
    ]));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

$domains = ["coursera.org", "zoom.us", "discord.com", "cheating-service.com"];
foreach ($domains as $domain) {
    $result = checkDomain($domain);
    echo "$domain: {$result['primary_category']} (risk: {$result['risk_level']})\n";
}

coursera.org

Education / E-Learning • risk: low

zoom.us

Business / Video Conferencing • risk: low

discord.com

Social Media / Messaging • risk: medium

cheating-service.com

Academic Fraud / Deceptive • risk: high

Internet Filtering Built for Schools