REST API for AI Domain
Lookups & Feed Integration

# Lookup a single domain
curl -H "Authorization: Bearer atb_your_api_key_here" \
     "https://api.aitoolsblocklist.com/v1/lookup/claude.ai"

# Response (200 OK) — domain is in the blocklist:
{
  "domain": "claude.ai",
  "in_blocklist": true,
  "primary_category": "Text & Language",
  "subcategory": "General assistants & chatbots",
  "confidence": 0.99,
  "risk_tier": "high",
  "data_handling": "cloud-processed",
  "status": "active",
  "first_seen": "2023-07-11T00:00:00Z",
  "last_verified": "2026-07-09T06:00:00Z"
}

# Response (200 OK) — domain is NOT in the blocklist:
{
  "domain": "example.com",
  "in_blocklist": false
}

import requests
import json
import time
from datetime import datetime, timedelta

API_KEY = "atb_your_api_key_here"
BASE_URL = "https://api.aitoolsblocklist.com/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def sync_blocklist(last_sync_file="last_sync.json"):
    # Load last sync state
    try:
        with open(last_sync_file) as f:
            state = json.load(f)
            domains = set(state["domains"])
            since = state["last_sync"]
    except FileNotFoundError:
        # First run — do a full load
        domains = set()
        since = None

    if since is None:
        # Full load with pagination
        cursor = None
        while True:
            params = {"limit": 10000}
            if cursor:
                params["cursor"] = cursor
            resp = requests.get(f"{BASE_URL}/domains",
                               headers=HEADERS, params=params)
            resp.raise_for_status()
            data = resp.json()
            for rec in data["domains"]:
                domains.add(rec["domain"])
            if not data["pagination"]["has_more"]:
                break
            cursor = data["pagination"]["cursor"]
        print(f"Full load complete: {len(domains)} domains")
    else:
        # Delta sync
        resp = requests.get(f"{BASE_URL}/delta",
                            headers=HEADERS,
                            params={"since": since})
        if resp.status_code == 429:
            retry = int(resp.headers.get("Retry-After", 60))
            print(f"Rate limited. Retrying in {retry}s.")
            time.sleep(retry)
            return sync_blocklist(last_sync_file)
        resp.raise_for_status()
        delta = resp.json()
        for rec in delta.get("added", []):
            domains.add(rec["domain"])
        for rec in delta.get("removed", []):
            domains.discard(rec["domain"])
        print(f"Delta sync: +{len(delta.get('added',[]))} "
              f"-{len(delta.get('removed',[]))} = {len(domains)} total")

    # Persist state
    with open(last_sync_file, "w") as f:
        json.dump({
            "domains": sorted(domains),
            "last_sync": datetime.utcnow().isoformat() + "Z"
        }, f)
    return domains

const API_KEY = 'atb_your_api_key_here';
const BASE    = 'https://api.aitoolsblocklist.com/v1';

async function checkDomain(domain) {
  const res = await fetch(
    `${BASE}/lookup/${encodeURIComponent(domain)}`,
    { headers: { 'Authorization': `Bearer ${API_KEY}` } }
  );

  if (res.status === 429) {
    const retry = parseInt(res.headers.get('Retry-After') || '60', 10);
    await new Promise(r => setTimeout(r, retry * 1000));
    return checkDomain(domain);
  }

  if (!res.ok) throw new Error(`API error: ${res.status}`);

  const data = await res.json();
  return data.in_blocklist ? data : null;
}

// Usage
const result = await checkDomain('claude.ai');
if (result) {
  console.log(`Blocked: ${result.domain} — ${result.primary_category}`);
} else {
  console.log('Domain is not an AI tool.');
}

// Bulk check from Node.js
async function bulkCheck(domains) {
  const res = await fetch(`${BASE}/bulk-lookup`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ domains })
  });
  const data = await res.json();
  return data.results.filter(r => r.in_blocklist);
}