aitoolsblocklist

A lightweight, zero-dependency Node.js client for the AI tools blocklist API: a daily-refreshed database of classified AI-tool domains built for web filtering, DNS security, data-loss prevention and acceptable-use enforcement. The package wraps the API in a small, typed interface so security engineers, network administrators and compliance teams can look up AI-tool domains, read the vendor's data-use terms and download the feed database from Node.js.

The underlying dataset is a specialized extraction from a 120-million-domain enterprise web filtering infrastructure. It contains 20,000+ AI-tool domains (chatbots, code assistants, image and video generators, voice-cloning services, autonomous agents, AI companions and more), each classified into one of 18 functional categories and a subcategory rather than a single flat "AI" label. That granularity is what makes per-category policy possible: permit an approved AI tutor while blocking a deepfake generator, or allow a coding assistant while flagging an unvetted document-processing service. Every record also states whether the vendor trains on customer input, with the date the terms were checked.

Installation

npm install aitoolsblocklist

No runtime dependencies. Node.js 14 and newer are supported, and TypeScript definitions ship with the package.

Quick start

const AIToolsBlocklistClient = require('aitoolsblocklist');

const client = new AIToolsBlocklistClient('YOUR_API_KEY');

(async () => {
  // Single lookup: is this domain an AI tool, and what kind?
  const result = await client.lookup('chatgpt.com');
  console.log(result.blocked);            // true
  console.log(result.primary_category);   // "Text & Language"
  console.log(result.ai_type);            // "ai_native"
  console.log(result.categories);         // [{ category: "Text & Language", subcategory: "General assistants & chatbots" }]
  console.log(result.trains_on_data);     // "opt_out_default"
  console.log(result.terms_checked);      // "2026-09-17"

  // A convenience boolean for policy gates
  if (await client.isBlocked('midjourney.com')) {
    enforceBlockPolicy('midjourney.com');
  }
})();

An API key is issued in the account area after subscribing to any plan and is sent as the X-API-Key header on every request. One lookup is charged per lookup() call. The public methods stats(), taxonomy() and clause() need no key.

Technical overview

Authentication and configuration

const client = new AIToolsBlocklistClient('YOUR_API_KEY', {
  baseUrl: 'https://www.aitoolsblocklist.com',  // default
  timeout: 30000,     // per-request timeout, ms; downloads use at least 300000
  maxRetries: 3,      // automatic backoff on 429, 503 and network errors
});

Transient failures (HTTP 429 and 503) are retried automatically with exponential backoff, honoring the Retry-After header when present. Authentication problems throw immediately, because retrying a revoked key is pointless.

Endpoints and methods

| Method | Endpoint | Key | Purpose | | --- | --- | --- | --- | | lookup(domain) | GET /api/check?domain= | yes | Classify one domain | | isBlocked(domain) | same | yes | Convenience boolean | | bulkLookup(domains, pauseMs) | same, sequential | yes | Deduplicated lookups, { results } in input order | | bulkLookupAll(domains, pauseMs) | same | yes | The flat array | | dataUse(domain) | same | yes | The five vendor data-use fields | | stats() | GET /api/stats.php | no | Totals and the 18 categories with counts | | taxonomy() | same | no | { name: { total, subcategories } } | | clause(domain, field) | GET /api/data-use-clause.php | no | Verbatim vendor clause with URL | | databaseStatus() | GET /api/database/?action=status | feed or database plan | Plan and file state | | databaseInfo() | GET /api/database/?action=database_info | feed or database plan | File name, timestamp, size | | downloadDatabase(path) | GET /api/database/?action=download_database | feed or database plan | Stream the full CSV to disk | | downloadCategories(path) | GET /api/database/?action=download_categories | feed or database plan | Stream the category tree CSV |

Lookups

Pass a bare domain or any URL; the client strips schemes, paths and a leading www. for you. Subdomains resolve to their registrable domain, so chat.openai.com returns the classification for openai.com. Both found and not-found responses are HTTP 200; your integration checks one unambiguous blocked boolean.

const report = await client.bulkLookup(['openai.com', 'github.com', 'notion.so'], 50);
for (const row of report.results) {
  console.log(row.domain, row.blocked, row.primary_category, row.trains_on_data);
}

A found record looks like this:

{
  "domain": "chatgpt.com",
  "blocked": true,
  "primary_category": "Text & Language",
  "ai_type": "ai_native",
  "categories": [{ "category": "Text & Language", "subcategory": "General assistants & chatbots" }],
  "trains_on_data": "opt_out_default",
  "opt_out_available": "yes",
  "enterprise_no_training": "yes",
  "api_no_training": "yes",
  "terms_checked": "2026-09-17",
  "quota_remaining": 9999986
}

Data-use values are yes, no, opt_out_default or unstated. ai_type is ai_native for tools that are the AI and ai_enabled for products with an AI feature inside. A domain that is not an AI tool returns blocked: false with an empty categories array.

Loading the full list

For a local cache, DNS sinkhole or firewall External Dynamic List, feed and database plans download the classified CSV and match locally:

const info = await client.databaseInfo();
console.log(info.database_file, info.last_updated, info.file_size_human);

await client.downloadDatabase('/var/lib/atb/ai_tools_full.csv');
await client.downloadCategories('/var/lib/atb/ai_tools_categories.csv');

Then a nightly cron re-downloads the file after the daily rebuild. This "download once a day, match locally" pattern lets a modest plan back millions of local lookups, because the actual matching happens in your own Redis, SQLite or flat file. Hosted feeds in EDL, PAC, hosts and DNS formats are also available in the account area for firewalls and resolvers that fetch their own lists.

Vendor terms, verbatim

const c = await client.clause('chatgpt.com', 'trains_consumer_default');
if (c) console.log(c.clause, c.url);

Fields: trains_consumer_default, optout_available, enterprise_no_training, api_no_training. The response is the sentence from the vendor's terms and the page it came from, which is what an approval ticket needs.

Error handling

const { AIToolsBlocklistError, AuthenticationError, QuotaError, PlanError, RateLimitError } = require('aitoolsblocklist');

try {
  const result = await client.lookup('example.com');
} catch (err) {
  if (err instanceof AuthenticationError) {
    // 401: rotate or renew the key
  } else if (err instanceof QuotaError) {
    // 403: inactive account or monthly quota exhausted
  } else if (err instanceof PlanError) {
    // 403 on the database endpoints: lookup-only plan, err.body.plan names it
  } else if (err instanceof RateLimitError) {
    // 429 after retries: back off or upgrade the plan
  } else if (err instanceof AIToolsBlocklistError) {
    // any other API or network failure; err.status and err.body are set
  }
}

Why domain-level AI classification is needed

The interface above solves a problem that has become urgent for nearly every organization that runs a network: you can no longer see, let alone govern, where your data goes when employees and students use AI tools.

Two years ago, "AI at work" meant a handful of well-known services. Today, thousands of AI products launch every month, each with its own domain, and each capable of receiving text, code, images or documents that a user pastes in. A blanket firewall rule cannot keep up, and a hand-maintained list of the famous fifty tools is stale within a week. The result is shadow AI: unsanctioned tools processing sensitive information with no oversight.

The data-governance problem

When an employee pastes a customer contract into an unfamiliar AI summarizer, or a developer sends proprietary source code to an online "explain this function" tool, that data leaves the organization's control. The U.S. National Institute of Standards and Technology's AI Risk Management Framework explicitly identifies data confidentiality and third-party dependency as core risks to be mapped and managed, and encourages organizations to maintain an inventory of the AI systems their people actually use. You cannot inventory what you cannot see, and you cannot see AI-tool usage at the network layer without knowing which of the millions of domains crossing your egress are AI tools in the first place. The OWASP Top 10 for LLM Applications lists sensitive information disclosure among the leading risks, and domain-level classification is the practical control point that turns an unbounded, ever-changing population of AI services into a queryable list your existing security stack can act on.

Education and duty of care

Schools face a sharper version of the same problem, layered on top of legal obligations. In the United States, districts that receive certain federal funding must operate a technology protection measure under the Children's Internet Protection Act; the Federal Communications Commission's CIPA guidance sets out the requirement. AI chatbots, essay generators and deepfake tools complicate that duty: a district may want to permit an approved AI tutor while blocking an essay-writing service or a companion-chat app inappropriate for minors. A single "AI" category cannot express that policy; per-subcategory classification can.

Why a purpose-built, refreshed feed

General web-categorization databases answer "is this a shopping site, a news site, a social network?", not "is this an AI code assistant, an AI voice cloner or an AI research agent?". The pace is also different: general categories are stable for years, whereas AI tools appear and disappear weekly. The dataset behind this client is rebuilt daily so that new tools are caught close to launch, and it is organized around the functional distinctions that policy actually turns on. Digital-rights organizations such as the Electronic Frontier Foundation emphasize that filtering must be precise and accountable rather than blunt, and precision is exactly what per-category domain intelligence enables.

Where this package fits

Drop lookup() into a proxy plugin or SOAR playbook for real-time decisions; use downloadDatabase() on a nightly cron to seed a DNS sinkhole or firewall EDL. Because the heavy matching runs locally against data you have already synced, the approach scales from a single script to millions of lookups a day without hammering the API. A Python client is published as aitoolsblocklist on PyPI, and a second client positioned for enforcement points, with a feeds sub-client and a Lookup object with accessors, is published as aiblocklist.

Discovery usually comes first: before writing a policy, most teams want a shadow AI inventory of the tools already in use. That hosted audit takes a DNS, proxy or firewall export and returns every AI tool reached from the network, who used it and whether the vendor trains on the data, as a dated CSV and PDF evidence pack, matched against the same list this client queries.

Related data from Alpha Quantum

Blocking risky AI tools governs what your people use; the complementary question is what your AI agents may touch on the web. An AI agent allow list supplies verified page-type URLs across 40 million+ domains, up to 28 page types each, so autonomous agents can research freely while credential and payment surfaces stay off-limits; its Node.js client is aiagentallowlist. NVIDIA's NeMo Guardrails describes the programmable rails such a policy plugs into.

Enterprises that extend AI-tool governance beyond a single policy area usually need broader coverage than an AI-only blocklist provides. The web filtering database supplies 120 million domains across 59 categories as a downloadable dataset for the same firewalls, DNS resolvers and secure web gateways, and the school web filtering solution provides the classification backbone CIPA programs depend on. An anti-phishing threat feed with 390,000+ DNS-verified active phishing domains lets the same resolver that blocks AI tools also block credential-harvesting pages, and a GDPR PII detection service scans prompts and DLP logs for personal data before it reaches an external model.

Frequently asked questions

What is the AI tools blocklist? The AI tools blocklist at aitoolsblocklist.com is a daily-refreshed database of 20,000+ AI-tool domains classified into 18 functional categories and their subcategories: chatbots and assistants, code assistants, image generators, video generators, voice cloning and speech, autonomous agents, AI companions, document and data tools, search and research tools and more. It is delivered as a lookup API and as ready-made feeds (EDL, PAC, hosts and DNS formats) for firewalls, DNS resolvers, secure web gateways and DLP systems.

How do I block ChatGPT, Gemini, Midjourney and other AI tools on a company or school network? Load the AI tools blocklist feed into the filter you already run: an External Dynamic List on a firewall, a PAC file for browsers, a hosts file or a DNS feed for resolvers. Then use the categories to allow the tools you sanction and block the rest. For real-time decisions in a proxy plugin or SOAR playbook, call the API with npm install aitoolsblocklist (Node.js) or pip install aitoolsblocklist (Python).

Can I allow some AI tools and block others? Yes. Every domain carries a primary category, a multi-label category list with subcategories, an AI type and the vendor's training terms, so a policy can permit an approved coding assistant or AI tutor while blocking deepfake, voice-cloning or companion-chat services. Paid plans also include 15 AI Policy Profiles with ready-made Block, Controls and Allow verdicts per sector.

Does the API say whether a vendor trains on my data? Yes. Each lookup returns trains_on_data, opt_out_available, enterprise_no_training, api_no_training and terms_checked, and clause() returns the verbatim sentence from the vendor's terms with its URL.

How is the AI tools blocklist different from the "AI" category in a web filtering product? General web filtering products classify sites by topic (shopping, news, social media) and usually offer one flat "generative AI" category that is updated on the vendor's schedule. The AI tools blocklist is a purpose-built feed: 18 categories with subcategories, AI types, training verdicts, and a daily rebuild so that tools are caught close to launch. It is extracted from a 120-million-domain web filtering infrastructure and is sold as data, so it works alongside any filtering product rather than replacing it.

How often is the AI tools blocklist updated? Daily. stats() shows the live totals without a key, and databaseInfo() shows the timestamp of the file your plan can download, so a nightly cron keeps a local copy current.

Is the AI tools blocklist suitable for schools and CIPA compliance? Yes. Districts and libraries use it to block essay generators, deepfake tools and companion chatbots while allowing approved AI tutors, and it complements the general filtering database that CIPA programs rely on; see cipawebfiltering.com.

What formats does the AI tools blocklist ship in? Lookup API (JSON), External Dynamic List (plain domain list for firewalls), PAC file, hosts file and DNS feeds, plus CSV and JSON downloads of the full classified list with categories.

Who builds the AI tools blocklist? Alpha Quantum, the company behind the web filtering database, the website categorization API, the AI agent allow list, which covers the other direction of AI governance, and the shadow AI detection audit.

Links

• Product and API documentation: https://www.aitoolsblocklist.com
• NIST AI Risk Management Framework: https://www.nist.gov/itl/ai-risk-management-framework
• OWASP Top 10 for LLM Applications: https://owasp.org/www-project-top-10-for-large-language-model-applications/
• FCC, Children's Internet Protection Act: https://www.fcc.gov/consumer-governmental-affairs/childrens-internet-protection-act
• NVIDIA NeMo Guardrails: https://developer.nvidia.com/nemo-guardrails
• Electronic Frontier Foundation: https://www.eff.org/

License

MIT

Related packages

• aiblocklist on npm and on PyPI, the enforcement-point client for the same API with a feeds sub-client
• aitoolsblocklist on PyPI, the Python version of this package
• shadowaitools on npm and on PyPI, local log scanner for shadow AI tools
• aiagentallowlist on npm and on PyPI, client for the allow list for AI agents
• phishingdetectionapi on npm and on PyPI, from phishingdetectionapi.com
• webfilteringdatabase on npm, from webfilteringdatabase.com
• websitecategorization on npm and websiteclassificationapi on PyPI, from websitecategorizationapi.com
• cipawebfiltering on npm and on PyPI, from cipawebfiltering.com
• PII detection API

Source: github.com/explainableaixai/aitoolsblocklist, mirror at gitlab.com/url-classifications/aitoolsblocklist.