npm install compliancelayer

import { ComplianceLayer } from 'compliancelayer';

const client = new ComplianceLayer({ apiKey: 'cl_your_api_key' });

// Run a scan and wait for results
const report = await client.scan('example.com');

console.log(`${report.domain}: ${report.grade} (${report.score}/100)`);
console.log(`Risk level: ${report.riskLevel}`);
console.log(`Issues found: ${report.issuesCount}`);

// Iterate over findings
for (const issue of report.issues) {
  console.log(`  [${issue.severity}] ${issue.finding}`);
  if (issue.remediation) {
    console.log(`    Fix: ${issue.remediation}`);
  }
}

// Scan multiple domains at once (up to 50)
const domains = [
  'example.com',
  'acme.org',
  'globex.net',
  'initech.io',
  'umbrella.co'
];

// Submit batch scan
const batch = await client.batchScan(domains);
console.log(`Batch ID: ${batch.batchId}`);
console.log(`Total domains: ${batch.total}`);

// Wait for all scans to complete
await batch.wait();

// Access individual results
for (const result of batch.results) {
  console.log(`${result.domain}: ${result.grade} (${result.score}/100)`);
}

// Get summary statistics
console.log(`Average score: ${batch.averageScore}`);
console.log(`Completed: ${batch.completedCount}/${batch.total}`);
console.log(`Failed: ${batch.failedCount}`);

// Compare security posture across domains
const comparison = await client.compare([
  'example.com',
  'competitor1.com',
  'competitor2.com'
]);

// Overall comparison
console.log(`Best: ${comparison.best.domain} (${comparison.best.score})`);
console.log(`Worst: ${comparison.worst.domain} (${comparison.worst.score})`);
console.log(`Average: ${comparison.averageScore}`);

// Module-level comparison
for (const [moduleName, scores] of Object.entries(comparison.byModule)) {
  console.log(`\n${moduleName}:`);
  for (const [domain, score] of Object.entries(scores)) {
    console.log(`  ${domain}: ${score}/100`);
  }
}

// Create a new webhook endpoint
const webhook = await client.webhooks.create({
  url: 'https://api.yourapp.com/webhooks/compliancelayer',
  events: ['scan.completed', 'alert.triggered'],
  description: 'Production webhook for scan results'
});

console.log(`Webhook ID: ${webhook.id}`);
console.log(`Secret: ${webhook.secret}`);  // Shown only once!
console.log(`Status: ${webhook.status}`);   // "active"

// Add a domain to monitoring
const domain = await client.domains.add({
  domain: 'example.com',
  scanInterval: 'weekly',    // "daily", "weekly", "monthly"
  alertThreshold: 70         // Alert if score drops below this
});

console.log(`Domain ID: ${domain.id}`);
console.log(`Monitoring: ${domain.domain}`);
console.log(`Scan interval: ${domain.scanInterval}`);
console.log(`Next scan: ${domain.nextScanAt}`);

// Get the badge URL for a domain
const url = client.badgeUrl('example.com');
console.log(`Badge URL: ${url}`);
// https://api.compliancelayer.net/v1/badge/example.com

// Use in Markdown
const markdown = `![Security Score](${url})`;

// Get the raw SVG content
const svg = await client.badgeSvg('example.com');
await fs.writeFile('badge.svg', svg);

// Customize badge style
const customUrl = client.badgeUrl('example.com', {
  style: 'flat',          // "flat", "flat-square", "plastic"
  label: 'Security'       // Custom left-side label
});

import { ComplianceLayer } from 'compliancelayer';

// Fully customized client
const client = new ComplianceLayer({
  apiKey: 'cl_your_api_key',
  baseUrl: 'https://api.compliancelayer.net/v1',
  timeout: 60_000,          // 60s HTTP timeout
  pollInterval: 3000,       // Poll every 3 seconds
  pollTimeout: 180_000,     // Wait up to 3 minutes for scans
  maxRetries: 5             // Retry up to 5 times on failures
});

// Or use environment variable for API key
// export COMPLIANCELAYER_API_KEY=cl_your_api_key
const envClient = new ComplianceLayer();  // Reads from env

import { ComplianceLayer } from 'compliancelayer';
import {
  ComplianceLayerError,    // Base error for all SDK errors
  APIError,                // Generic API error (non-2xx response)
  AuthenticationError,     // Invalid or missing API key (401)
  ForbiddenError,          // Insufficient permissions (403)
  NotFoundError,           // Resource not found (404)
  RateLimitError,          // Rate limit exceeded (429)
  QuotaExceededError,      // Scan quota exhausted
  ValidationError,         // Invalid request parameters (422)
  ScanTimeoutError,        // Scan polling timed out
  ScanFailedError,         // Scan execution failed
  ServerError,             // Server-side error (5xx)
  ConnectionError,         // Network connectivity issue
} from 'compliancelayer';

const client = new ComplianceLayer({ apiKey: 'cl_your_api_key' });

try {
  const report = await client.scan('example.com');
  console.log(`Score: ${report.score}`);

} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Invalid API key. Check your credentials.');

  } else if (error instanceof QuotaExceededError) {
    console.error(`Scan quota exhausted. Resets at: ${error.resetAt}`);
    console.error(`Current usage: ${error.used}/${error.limit}`);

  } else if (error instanceof RateLimitError) {
    console.error(`Rate limited. Retry after ${error.retryAfter}s.`);

  } else if (error instanceof ScanTimeoutError) {
    console.error('Scan took too long. Increase pollTimeout.');

  } else if (error instanceof ScanFailedError) {
    console.error(`Scan failed: ${error.reason}`);
    console.error(`Domain: ${error.domain}`);

  } else if (error instanceof ValidationError) {
    console.error(`Invalid input: ${error.detail}`);
    for (const err of error.errors) {
      console.error(`  Field '${err.field}': ${err.message}`);
    }

  } else if (error instanceof ServerError) {
    console.error('ComplianceLayer server error. Try again later.');

  } else if (error instanceof ConnectionError) {
    console.error('Network error. Check your internet connection.');

  } else if (error instanceof ComplianceLayerError) {
    // Catch-all for any SDK error
    console.error(`Unexpected error: ${error.message}`);
  }
}

interface ScanReport {
  /** The scanned domain */
  domain: string;

  /** Numeric score from 0 to 100 */
  score: number;

  /** Letter grade: A, B, C, D, or F (with optional +/-) */
  grade: string;

  /** Risk classification */
  riskLevel: 'low' | 'low_medium' | 'medium' | 'high' | 'critical';

  /** Unique report identifier */
  reportId: string;

  /** ISO 8601 timestamp of scan completion */
  scannedAt: string;

  /** Total number of issues found */
  issuesCount: number;

  /** Issue counts by severity */
  criticalIssues: number;
  highIssues: number;
  mediumIssues: number;
  lowIssues: number;

  /** Individual module results keyed by module name */
  modules: Record<string, ModuleResult>;

  /** All issues sorted by severity */
  issues: ScanIssue[];

  /** Compliance framework mappings */
  compliance: ComplianceMapping;

  /** Prioritized remediation recommendations */
  recommendations: string[];

  /** Caveats about the assessment methodology */
  caveats: string[];
}

import { verifyWebhookSignature } from 'compliancelayer';
import express from 'express';

const app = express();

app.post(
  '/webhooks/compliancelayer',
  express.raw({ type: 'application/json' }),
  (req, res) => {
    const signature = req.headers['x-compliancelayer-signature'] as string;
    const payload = req.body.toString('utf8');
    const secret = process.env.WEBHOOK_SECRET!;

    // Verify the signature (throws if invalid)
    try {
      verifyWebhookSignature(payload, signature, secret);
    } catch {
      return res.status(401).send('Invalid signature');
    }

    // Safe to process the event
    const event = JSON.parse(payload);
    console.log(`Event: ${event.type}`);

    res.status(200).send('OK');
  }
);

// Automatic pagination with async iteration
for await (const domain of client.domains.list()) {
  console.log(`${domain.domain}: ${domain.latestScore}`);
}

// Manual pagination with page size control
const page = await client.domains.list({ limit: 25 });
console.log(`Total domains: ${page.total}`);
console.log(`Page 1 of ${page.totalPages}`);

for (const domain of page.items) {
  console.log(`  ${domain.domain}`);
}

// Get next page
if (page.hasNext) {
  const nextPage = await page.next();
}

const controller = new AbortController();

// Cancel after 10 seconds
setTimeout(() => controller.abort(), 10_000);

try {
  const report = await client.scan('example.com', {
    signal: controller.signal
  });
  console.log(`Score: ${report.score}`);
} catch (error) {
  if (error instanceof DOMException && error.name === 'AbortError') {
    console.log('Scan request was cancelled');
  }
}

import { ComplianceLayer } from 'compliancelayer';

// Enable debug mode via environment variable
// DEBUG=compliancelayer* node app.js

// Or programmatically
const client = new ComplianceLayer({
  apiKey: 'cl_your_api_key',
  debug: true   // Logs all requests to console
});

// Output:
// [compliancelayer] POST /v1/scan {"domain":"example.com"}
// [compliancelayer] 200 OK (234ms)
// [compliancelayer] GET /v1/scan/jobs/12345
// [compliancelayer] 200 OK {"status":"completed",...}

import express from 'express';
import { ComplianceLayer } from 'compliancelayer';

const app = express();
const cl = new ComplianceLayer({ apiKey: process.env.CL_API_KEY });

app.get('/api/scan/:domain', async (req, res) => {
  try {
    const report = await cl.scan(req.params.domain);
    res.json({
      domain: report.domain,
      score: report.score,
      grade: report.grade,
      issues: report.issuesCount
    });
  } catch (error) {
    if (error.statusCode === 429) {
      res.status(429).json({ error: 'Rate limited' });
    } else {
      res.status(500).json({ error: 'Scan failed' });
    }
  }
});

app.listen(3000);

// app/actions/scan.ts
'use server';

import { ComplianceLayer } from 'compliancelayer';

const client = new ComplianceLayer({
  apiKey: process.env.COMPLIANCELAYER_API_KEY
});

export async function scanDomain(domain: string) {
  const report = await client.scan(domain);

  return {
    domain: report.domain,
    score: report.score,
    grade: report.grade,
    riskLevel: report.riskLevel,
    issues: report.issues.map(i => ({
      severity: i.severity,
      finding: i.finding,
      remediation: i.remediation
    }))
  };
}