Node.js SDK

npm install compliancelayer

import { ComplianceLayer } from "compliancelayer";

const client = new ComplianceLayer({ apiKey: "cl_your_api_key_here" });

// Submit and wait for the result
const job = await client.scanAndWait("example.com");
console.log(job.domain, job.grade, job.score);

// Then pull the full report
const report = await job.getReport();
console.log(`${report.totalIssues} issues (${report.criticalIssues} critical)`);

for (const issue of report.issues.slice(0, 5)) {
  console.log(`[${issue.severity}] ${issue.finding}`);
}

import { ComplianceLayer } from "compliancelayer";

const client = new ComplianceLayer({
  apiKey: process.env.COMPLIANCELAYER_API_KEY!,
  timeout: 60_000,
  pollInterval: 5_000,
  pollTimeout: 300_000,
  maxRetries: 5,
});

const job = await client.scan("example.com");
console.log(job.jobId, job.status);   // e.g. 12345 "queued"

// Poll manually
while (!job.isComplete) {
  await new Promise((r) => setTimeout(r, 3000));
  await job.refresh();
}

if (job.status === "failed") {
  console.error("Scan failed:", job.failureReason);
} else {
  const report = await job.getReport();
  console.log(report.grade, report.score);
}

const batch = await client.batchScan([
  "example.com",
  "example.org",
  "example.net",
]);

console.log(`${batch.total} domains scanned`);
console.log(batch.summary);

for (const result of batch.results) {
  if (result.error) {
    console.warn(`${result.domain}: ${result.error}`);
  } else {
    console.log(result.domain, result.overallGrade, result.overallScore);
  }
}

const domain = await client.domains.create({
  domain: "example.com",
  scan_frequency: "daily",
  alert_on_score_drop: true,
  alert_threshold: 5,          // alert on a drop of 5+ points
});

console.log(domain.id, domain.domain, domain.scanFrequency);

const listing = await client.domains.list();
console.log(`${listing.limitUsed} of ${listing.limitMax} domains in use`);

for (const d of listing.domains) {
  console.log(d.id, d.domain, d.lastScore, d.lastGrade);
}

await client.domains.delete(domain.id);

const endpoint = await client.webhooks.create({
  url: "https://example.com/hooks/compliancelayer",
  enabled_events: ["scan.completed", "alert.triggered"],
  description: "Production listener",
});

// The signing secret is only returned on creation -- store it now.
console.log(endpoint.id, endpoint.secret);

const test = await client.webhooks.test(endpoint.id);
console.log(test.success, test.statusCode, test.responseTimeMs);

for (const delivery of await client.webhooks.deliveries(endpoint.id)) {
  console.log(delivery.createdAt, delivery.eventType, delivery.status);
  console.log("  HTTP", delivery.httpStatusCode, "retries:", delivery.retryCount);
  if (delivery.errorMessage) console.log("  error:", delivery.errorMessage);
}

// update() issues a PATCH -- send only the fields you want to change
await client.webhooks.update(endpoint.id, { is_active: false });

// URL builders -- no network call
const svgUrl = client.badgeSvgUrl("example.com");
console.log(`![Security](${svgUrl})`);   // public: safe to embed in a README

// Authenticated fetch of the badge payload
const badge = await client.getBadge("example.com");
console.log(badge.domain, badge.grade, badge.score);

// Same endpoint as getBadge(), so it needs an API key to load
const jsonUrl = client.badgeJsonUrl("example.com");

const account = await client.me();

console.log(account.email, account.plan);
console.log(account.scansThisMonth, "of", account.scanLimit, "scans used");
console.log(account.scansRemaining, "remaining");
console.log("Domain limit:", account.domainLimit);

// The endpoint does not report domains in use -- read it from the list:
const { limitUsed } = await client.domains.list();
console.log(limitUsed, "domains in use");

import {
  ComplianceLayer,
  APIError,
  AuthenticationError,
  QuotaExceededError,
  RateLimitError,
  ScanError,
  ScanTimeoutError,
  ValidationError,
} from "compliancelayer";

const client = new ComplianceLayer({ apiKey: "cl_your_api_key_here" });

try {
  const job = await client.scanAndWait("example.com");
  console.log(job.grade, job.score);
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error("Check your API key.");
  } else if (error instanceof QuotaExceededError) {
    console.error("Monthly scan quota exhausted.");
  } else if (error instanceof RateLimitError) {
    console.error(`Rate limited; retry after ${error.retryAfter}s`);
  } else if (error instanceof ValidationError) {
    console.error("Invalid request:", error.message);
  } else if (error instanceof ScanTimeoutError) {
    console.error(`Job ${error.jobId} did not finish in time.`);
  } else if (error instanceof ScanError) {
    console.error("Scan failed:", error.message);
  } else if (error instanceof APIError) {
    console.error(`API error ${error.status}:`, error.message);
  } else {
    throw error;
  }
}

import type {
  ComplianceLayerOptions,
  ScanJobResponse,
  ScanReport,
  ScanHistoryResponse,
  FreeScanResult,
  BatchScanResponse,
  BatchCompareResponse,
  DomainScanResult,
  RankedDomain,
  Domain,
  DomainListResponse,
  DomainAlert,
  Webhook,
  WebhookDelivery,
  WebhookTestResult,
  BadgeJson,
  AccountInfo,
  Finding,
  ModuleResult,
} from "compliancelayer";

function summarize(report: ScanReport): string {
  return `${report.domain}: ${report.grade} (${report.score})`;
}

const fakeFetch: typeof fetch = async () =>
  new Response(JSON.stringify({ job_id: 1, domain: "example.com", status: "queued" }), {
    status: 200,
    headers: { "content-type": "application/json" },
  });

const client = new ComplianceLayer({
  apiKey: "cl_test_key",
  fetch: fakeFetch,
});