AI Tools Blocklist
Home AI Tools Database Taxonomy Pricing
Solutions
Enterprise IT & CISO Education Firewall Admins Shadow AI Prevention
Integrations
Palo Alto Networks FortiGate Cisco Umbrella pfSense REST API
Download Free Sample
K-12 Content Filtering

K-12 AI Content Filtering Guide
GoGuardian · Lightspeed · Securly

Your content filter wasn't built for generative AI -- it misses the 16,024+ AI tools students access daily. This guide shows you how to close that gap using the filter you already run.

16,024+
AI Domains Classified
18
Functional Categories
5
Major Filters Supported
Daily
Feed Updates
Download Free Sample Education Pricing
The Gap

Why Traditional Content Filters Miss AI Tools

Filter vendors built their taxonomies around decades-old threat categories: pornography, violence, gambling, social media. Generative AI doesn't fit any of those buckets -- creating a blind spot that students exploit daily.

No AI Category Exists

Most K-12 filters ship with 60-80 URL categories. None include a dedicated "AI Tools" category.

ChatGPT classified as "Technology" or "Productivity" -- typically allowed
Hundreds of lesser-known AI chatbots completely uncategorized
Uncategorized domains pass through without a second look

New Tools Launch Daily

The AI landscape is not static. A hand-curated spreadsheet cannot keep pace.

Our crawlers discover 300K+ new candidate domains every day
Dozens of confirmed AI tools identified and classified daily
By the time a manual list is updated, students have found three more

Students Share Workarounds

Block ChatGPT and students share alternatives on TikTok and Discord within hours.

Obscure paraphrasing sites and homework solvers spread fast
Anonymous chatbot mirrors are where academic dishonesty actually happens
Blocking the top 5 AI brands is necessary but nowhere near sufficient

The AI Tools Blocklist closes this gap with a single, daily-updated feed of 16,024+ AI-tool domains classified into 18 functional categories. The feed works with every major K-12 content filter. The rest of this guide walks through integration step by step.

Comparison

Content Filter Compatibility at a Glance

Every major K-12 content filter supports custom URL lists or external feed imports. The table below summarizes ingestion methods and automation levels.

Filter Platform Custom Lists External Feed URL API Import Auto-Refresh OU-Level Policy
GoGuardian Admin Via script
Lightspeed Filter / Relay Native
Securly Native
iBoss Cloud Native
ContentKeeper Native

All five platforms support importing a domain list and blocking it for specific OUs or user groups. The differences are in how the list gets in (manual upload, URL polling, or API push) and how often it refreshes. Integration guides for each platform follow below.

GoGuardian

GoGuardian Admin Integration

GoGuardian is the dominant K-12 content filter in the US, deployed on 25M+ Chromebooks. Its agent-based model filters every URL request regardless of network.

Custom List Import

Add the blocklist via Filtering → Custom Lists → Create New List. The block takes effect within minutes across every managed Chromebook.

Name the list "AI Tools Blocklist" and set action to "Block"
Paste domains directly or upload a text file (one domain per line)
Assign the list to your "Students" OU

List limit: ~10,000 entries per list. For 16,024+ domains, split across multiple lists or use the API method below.

OU-Level Policy Targeting

Apply the blocklist to student OUs only -- teachers often need AI tools for lesson planning. Configure under Policies → Edit Policy → Select OUs.

Grade-level customization:
Elementary: Block all 18 categories
High school AP CS: Unblock "Code & Development" category
Create separate custom lists per grade band with different category selections

See the taxonomy reference for all 18 categories.

Automated GoGuardian Sync via Google Apps Script

Manual CSV uploads go stale within 24 hours. This Google Apps Script automates the sync.

Fetches latest blocklist feed
Splits into 5K-domain chunks
Saves to Drive for import
Logs every sync event
// Google Apps Script — Automated AI Blocklist Sync for GoGuardian
// Deploy as a daily time-driven trigger in your Google Workspace

function syncAIBlocklistToGoGuardian() {
  const API_KEY = PropertiesService.getScriptProperties().getProperty('BLOCKLIST_API_KEY');
  const FEED_URL = 'https://feeds.aitoolsblocklist.com/v1/domains/education.txt';
  const LOG_SHEET = 'AI Blocklist Sync Log';

  // Step 1: Fetch the latest AI tools domain feed
  const response = UrlFetchApp.fetch(FEED_URL, {
    headers: { 'Authorization': 'Bearer ' + API_KEY },
    muteHttpExceptions: true
  });

  if (response.getResponseCode() !== 200) {
    Logger.log('Feed fetch failed: ' + response.getResponseCode());
    return;
  }

  const domains = response.getContentText()
    .split('\n')
    .filter(d => d.trim().length > 0 && !d.startsWith('#'));

  Logger.log('Fetched ' + domains.length + ' AI tool domains');

  // Step 2: Split into chunks of 5,000 for GoGuardian list limits
  const CHUNK_SIZE = 5000;
  const chunks = [];
  for (let i = 0; i < domains.length; i += CHUNK_SIZE) {
    chunks.push(domains.slice(i, i + CHUNK_SIZE));
  }

  // Step 3: Generate importable text files for each chunk
  chunks.forEach((chunk, idx) => {
    const blob = Utilities.newBlob(
      chunk.join('\n'),
      'text/plain',
      'ai-blocklist-part-' + (idx + 1) + '.txt'
    );
    DriveApp.getFolderById('YOUR_DRIVE_FOLDER_ID').createFile(blob);
  });

  // Step 4: Log the sync event
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  let sheet = ss.getSheetByName(LOG_SHEET);
  if (!sheet) sheet = ss.insertSheet(LOG_SHEET);
  sheet.appendRow([
    new Date(),
    domains.length + ' domains',
    chunks.length + ' chunks generated',
    'SUCCESS'
  ]);
}
Lightspeed

Lightspeed Filter & Relay Integration

Lightspeed offers two filtering products for K-12: cloud-based Filter and proxy-based Relay. Both support custom categories and external feed URLs for straightforward integration.

Lightspeed Filter (Cloud Agent)

Uses smart agents on Chromebooks, Windows, macOS, and iOS. Supports external feed URLs for automatic refresh.

Navigate to Filter → Categories → Custom Categories
Create a new "AI Tools" category, set action to "Block"
Point to our hosted feed URL for auto-refresh
Assign to student policies

Lightspeed Relay (Proxy-Based)

Uses the proxy's custom URL categorization engine. Supports bulk imports of up to 50K URLs per category.

Navigate to Web Filter → Custom URLs → Add Category
Create "AI Tools" category, default action to "Block"
Upload domain feed (full blocklist fits within 50K limit)
Set refresh interval to 24 hours

Lightspeed Custom Category Configuration

Create a custom AI Tools category with external feed polling using Lightspeed's management API.

# Lightspeed Filter — Custom Category Configuration
# Navigate to: Filter → Categories → Custom Categories → New

Category Name:     "AI Tools"
Category Type:     Custom URL List
Default Action:    Block
Block Page:        "This AI tool is blocked per district policy."

# External feed configuration
Feed URL:          https://feeds.aitoolsblocklist.com/v1/domains/education.txt
Feed Format:       Plain text (one domain per line)
Refresh Interval: 86400 # seconds (24 hours)
Auth Header:       Authorization: Bearer YOUR_API_KEY

# Policy assignment
Apply to:          Students OU
Schedule:          Always # or set testing-period schedule
Override:          Allow teachers to bypass via Lightspeed Classroom

# Verification — test from a student device:
$ curl -s -o /dev/null -w "%{http_code}" https://chatgpt.com
# Expected: 403 or redirect to block page

Lightspeed Classroom bonus: Teachers can temporarily unlock specific AI tools for their class period (e.g., ChatGPT for an AI literacy lesson) while it stays blocked for everyone else. Configure under Teacher Override → Allow Category Bypass.

Securly

Securly Integration & Reporting

Securly combines content filtering with student safety monitoring. Its filtering engine supports custom URL lists, external feeds, and granular reporting.

Custom URL Lists

Supports up to 100K custom URLs -- ample capacity for the full blocklist.

Go to Filter → Custom URLs
Create "AI Tools" list, set to "Block"
Upload domain feed and assign to policy group

AI Activity Reports

See attempted access by user, time, and category in the reporting dashboard.

Reports → Custom Categories → AI Tools
Identify students needing AI policy education
Demonstrate policy enforcement to administrators

Alert Integration

Get notified when AI tool access attempts exceed a threshold.

Settings → Alerts → Custom Category Threshold
Example: Alert at 10+ attempts per student per day
Flags persistent bypass attempts for follow-up

Securly API Integration

Automate list updates via Securly's management API. Deploy as a scheduled task on your management server.

Downloads latest feed
Pushes to Securly API
Runs daily via cron
# Securly Custom URL List — Automated Update Script
# Run daily via cron or Task Scheduler

#!/bin/bash
# /opt/scripts/securly-ai-sync.sh

BLOCKLIST_KEY="your-aitoolsblocklist-api-key"
SECURLY_KEY="your-securly-api-key"
SECURLY_ORG="your-securly-org-id"
FEED_URL="https://feeds.aitoolsblocklist.com/v1/domains/education.txt"
TEMP_FILE="/tmp/ai-blocklist-securly.txt"

# Download the latest feed
curl -sS -H "Authorization: Bearer $BLOCKLIST_KEY" \
     "$FEED_URL" -o "$TEMP_FILE"

DOMAIN_COUNT=$(wc -l < "$TEMP_FILE")
echo "[$(date)] Downloaded $DOMAIN_COUNT AI tool domains"

# Push to Securly custom URL list
curl -sS -X PUT \
     -H "Authorization: Bearer $SECURLY_KEY" \
     -H "Content-Type: text/plain" \
     -d @"$TEMP_FILE" \
     "https://api.securly.com/v1/orgs/$SECURLY_ORG/custom-urls/ai-tools"

echo "[$(date)] Securly AI Tools list updated: $DOMAIN_COUNT domains"
rm -f "$TEMP_FILE"
Additional Platforms

iBoss Cloud & ContentKeeper

iBoss Cloud

Zero Trust network security with integrated content filtering. Supports EDL (External Dynamic List) endpoints natively.

Setup steps:
Policy → Custom Categories → Create "AI Tools" category
Paste feed URL -- iBoss polls at your configured interval
STIX/TAXII feeds also available for threat intel platforms
Key advantage:

Cloud connector extends filtering off-network to Windows, macOS, iOS, and Android -- broader device coverage than Chromebook-only solutions.

ContentKeeper

On-premises and cloud-hosted filtering used in K-12 across the US, Australia, and UK. Minimum feed refresh interval of 15 minutes.

Setup steps:
Web Policy → Custom Categories → Add Feed
Configure feed URL and refresh interval
Assign to student policies
Key advantage:

SSL inspection detects AI tool access even through VPN tunnels or web proxies -- blocking by domain within encrypted traffic. See the firewall admin guide for SSL inspection strategies.

Granular Control

Category-Level Filtering for Nuanced Policies

Not every AI tool carries the same risk. Our 18-category taxonomy lets you block what undermines learning and allow what supports it.

Per-domain category labels

Every domain carries a primary category and subcategory label.

Server-side filtering

Include or exclude categories in the feed request. Your filter only receives the domains you want blocked.

Example policy

Block AI essay writers and chatbots while allowing AI-powered math tutoring platforms.

Commonly Blocked in K-12

Text & Language Image & Visual Code & Development Agents & Automation Audio, Voice & Music Video General AI Chatbots Data, Analytics & Research

Often Allowed (With Oversight)

Education & Learning Security & Detection Accessibility

Even permitted categories can be narrowed by subcategory. Allow AI reading assistants while blocking AI homework solvers. Preview every domain in the database explorer.

API Feed with Category Filtering

The feed API supports category inclusion and exclusion parameters for custom domain lists.

# Fetch AI Tools Blocklist with category filtering
# Block all AI categories except Education & Learning

$ curl -H "Authorization: Bearer YOUR_API_KEY" \
     "https://feeds.aitoolsblocklist.com/v1/domains/education.txt?exclude=education-learning"

# Block only text/language and chatbot categories (minimum block)
$ curl -H "Authorization: Bearer YOUR_API_KEY" \
     "https://feeds.aitoolsblocklist.com/v1/domains/education.txt?include=text-language,chatbots"

# Full block for testing periods (all 18 categories)
$ curl -H "Authorization: Bearer YOUR_API_KEY" \
     "https://feeds.aitoolsblocklist.com/v1/domains/all.txt"

# JSON format with metadata (for API integrations)
$ curl -H "Authorization: Bearer YOUR_API_KEY" \
     "https://feeds.aitoolsblocklist.com/v1/domains/education.json"

# Response includes domain, category, subcategory, and risk score:
# {"domain":"chatgpt.com","category":"General AI Chatbots",
#  "subcategory":"Multi-purpose AI Assistant","risk":"high"}
Automation

Policy Deployment Automation

Districts managing hundreds of schools need automated deployment. These scripts handle feed sync, multi-filter deployment, and logging.

PowerShell: Multi-Filter Deployment Script

Runs on a Windows management server, updating multiple content filters in parallel. Schedule via Task Scheduler at 5:00 AM daily.

Fetches latest feed
Saves local audit copy
Pushes to filters in parallel
Logs every update
# PowerShell — Multi-Filter AI Blocklist Deployment
# Schedule: Daily at 05:00 via Task Scheduler
# Requires: PowerShell 5.1+, network access to filter APIs

$ErrorActionPreference = "Stop"
$LogPath = "C:\Logs\AI-Blocklist\sync-$(Get-Date -Format 'yyyy-MM-dd').log"

function Write-SyncLog($Message) {
    $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    "[$Timestamp] $Message" | Tee-Object -FilePath $LogPath -Append
}

# Step 1: Fetch the latest AI Tools Blocklist
Write-SyncLog "Fetching AI Tools Blocklist feed..."
$Headers = @{ "Authorization" = "Bearer $env:BLOCKLIST_API_KEY" }
$FeedUrl = "https://feeds.aitoolsblocklist.com/v1/domains/education.txt"
$Domains = (Invoke-RestMethod -Uri $FeedUrl -Headers $Headers).Split("`n") |
    Where-Object { $_.Trim() -ne "" -and -not $_.StartsWith("#") }

Write-SyncLog "Downloaded $($Domains.Count) AI tool domains"

# Step 2: Save local copy for audit trail
$LocalPath = "C:\Data\AI-Blocklist\current-feed.txt"
$Domains | Out-File -FilePath $LocalPath -Encoding UTF8
Write-SyncLog "Local copy saved to $LocalPath"

# Step 3: Push to content filters in parallel
$Jobs = @()

# Securly update
$Jobs += Start-Job -ScriptBlock {
    param($Domains, $Key, $OrgId)
    $Body = $Domains -join "`n"
    Invoke-RestMethod -Method Put `
        -Uri "https://api.securly.com/v1/orgs/$OrgId/custom-urls/ai-tools" `
        -Headers @{ "Authorization" = "Bearer $Key" } `
        -Body $Body -ContentType "text/plain"
} -ArgumentList $Domains, $env:SECURLY_KEY, $env:SECURLY_ORG

# Wait for all jobs and log results
$Jobs | Wait-Job | ForEach-Object {
    $Result = Receive-Job -Job $_
    Write-SyncLog "Filter update completed: $($_.Name)"
}

Write-SyncLog "All filters updated successfully"
Rollout

District Rollout Best Practices

A rushed rollout that blocks teacher-approved tools generates support tickets and pushback. Follow this phased approach to minimize disruption.

1

Week 1 — Audit Mode

Deploy in log-only mode (set action to "Allow + Log"). Generate a baseline report of which AI tools are currently in use without disrupting anyone.

2

Week 2 — Communicate

Share audit results with principals and department heads. Build an exception list of approved tools and notify students and parents. See our policy guide for templates.

3

Week 3 — Pilot Block

Enable blocking for one school or grade level. Monitor for false positives, adjust exceptions, and confirm teacher override mechanisms work correctly.

4

Week 4 — Full Deployment

Roll the block to all student OUs district-wide. Set up weekly dashboards for IT and monthly reports for admins. Establish a 24-hour exception request process for teachers.

Monitoring

Monitoring, Reporting & Compliance

Deploying the blocklist is only half the job. Ongoing monitoring ensures the filter works and provides documentation for auditors.

Real-Time Dashboard Metrics

Aggregate block logs into a dashboard (built-in reporting, a SIEM, or even a Google Sheet). Track three key metrics:

Total AI block events per day -- is attempted use increasing or decreasing?
Top blocked domains -- which AI tools do students try to reach most?
Top users by block count -- who is persistently attempting bypass?

These metrics demonstrate active protection to administrators and identify students who may need conversations about academic integrity expectations.

Compliance Documentation

CIPA compliance reviewers and E-Rate auditors increasingly ask about AI-tool access. The subscription includes documentation artifacts:

Methodology summary (how domains are identified and classified)
Daily feed update timestamps proving the list is current
Category coverage statistics
Change logs (domains added/removed on any given date)

Combine these with your block logs and written AI policy for a complete compliance package that turns audit findings into clean passes.

Feed Health Monitoring Script

Verifies your feed is updating and your filter is actively blocking AI domains. Run daily as part of IT operations monitoring.

Checks feed freshness
Validates domain count
Tests sample block verification
Sends email alerts on failure
#!/bin/bash
# /opt/scripts/ai-blocklist-health-check.sh
# Run daily via cron — alerts on feed staleness or block failures

API_KEY="your-api-key"
ALERT_EMAIL="[email protected]"
MIN_DOMAINS=40000
SAMPLE_DOMAINS=("chatgpt.com" "claude.ai" "quillbot.com" "perplexity.ai")

# Check 1: Feed freshness
FEED_HEADERS=$(curl -sI -H "Authorization: Bearer $API_KEY" \
  "https://feeds.aitoolsblocklist.com/v1/domains/education.txt")
LAST_MODIFIED=$(echo "$FEED_HEADERS" | grep -i "last-modified")
echo "Feed $LAST_MODIFIED"

# Check 2: Domain count
DOMAIN_COUNT=$(curl -s -H "Authorization: Bearer $API_KEY" \
  "https://feeds.aitoolsblocklist.com/v1/domains/education.txt" | wc -l)
echo "Domain count: $DOMAIN_COUNT"

if [ "$DOMAIN_COUNT" -lt "$MIN_DOMAINS" ]; then
  echo "WARNING: Domain count below threshold ($DOMAIN_COUNT < $MIN_DOMAINS)" |
    mail -s "AI Blocklist Alert: Low Domain Count" "$ALERT_EMAIL"
fi

# Check 3: Sample block verification from student VLAN
FAILURES=0
for domain in "${SAMPLE_DOMAINS[@]}"; do
  RESULT=$(nslookup "$domain" 10.0.50.1 2>&1)  # student DNS resolver
  if echo "$RESULT" | grep -q "NXDOMAIN\|SERVFAIL\|0.0.0.0"; then
    echo "PASS: $domain is blocked"
  else
    echo "FAIL: $domain resolved — block may not be active"
    FAILURES=$((FAILURES + 1))
  fi
done

if [ "$FAILURES" -gt 0 ]; then
  echo "$FAILURES sample domains resolved — check content filter config" |
    mail -s "AI Blocklist Alert: Block Verification Failed" "$ALERT_EMAIL"
fi
Closing the Gap

Bridging Traditional Content Filters and AI Tool Coverage

The Core Problem

Traditional filters categorize websites around content risk: pornography, violence, gambling. AI tools don't fit these buckets -- they aren't inherently harmful content, but they enable behaviors schools need to control.

Some vendors have added an "AI" category, but coverage is limited to well-known brands. A vendor that categorizes 50 AI tools misses the vast long tail of 16,024+ domains that comprise the real landscape.

YOUR EXISTING FILTER

CIPA-mandated categories

AI TOOLS BLOCKLIST

AI-specific categorization

COMPLETE COVERAGE

Both layers in parallel

Layered Architecture

Your filter handles CIPA categories. The blocklist handles AI-specific categorization. Both operate simultaneously -- no rip-and-replace required.

Daily-Updated Intelligence

Filter vendors update weekly or monthly. The AI Tools Blocklist updates daily, scanning 300K+ candidates and classifying new AI tools within hours of discovery.

No Per-Student Cost

Priced per district regardless of student count. No software to install, no agents to deploy, no change management required. See education pricing.

Integrate AI Filtering Into Your Content Filter Today

Download the free sample to see the data, or tell us about your district's content filtering setup and we will provide integration guidance specific to your platform.

Download Free Sample Explore the Database

Request K-12 Integration Support

Tell us your content filter vendor, student count, and device platform — we will send you a step-by-step integration guide tailored to your stack.