SDKs & Libraries

Scan Text for Secrets

from netallion_detection import DetectionEngine

engine = DetectionEngine(enable_bpe=True)

# Scan a text string
result = engine.scan_text(
    "aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
)

for match in result.matches:
    print(f"{match.pattern_name}: {match.severity}")
    print(f"  Confidence: {match.confidence_score}")
    print(f"  Hash: {match.secret_hash[:16]}...")
    print(f"  Redacted: {match.redacted_snippet}")

Scan Files

from netallion_detection import DetectionEngine
from pathlib import Path

engine = DetectionEngine(enable_bpe=True)

# Scan a file
for finding in engine.scan_file(Path("config.yaml")):
    print(f"[{finding.severity}] {finding.pattern_name}")
    print(f"  Line {finding.line_number}: {finding.redacted_snippet}")

# Scan a directory
for finding in engine.scan_directory(
    Path("./src"),
    exclude_patterns=["*.test.*", "node_modules/**"],
):
    print(f"{finding.file_path}:{finding.line_number} {finding.pattern_name}")

API Client

import httpx

API_URL = "https://api.netallion.ai/api/v1"
headers = {"Authorization": "Bearer cfk_your_api_key"}

# List incidents
r = httpx.get(f"{API_URL}/incidents", headers=headers,
              params={"severity": "critical", "status": "open"})
incidents = r.json()["items"]

# Trigger scan
r = httpx.post(f"{API_URL}/scans", headers=headers,
               json={"workspace_id": "ws-uuid"})

# Scan a prompt before sending to AI
r = httpx.post(f"{API_URL}/prompt-dlp/scan", headers=headers,
               json={
                   "payload": {"messages": [{"role": "user", "content": code}]},
                   "provider": "openai",
                   "mode": "redact",
               })
if r.json()["action"] == "blocked":
    print("Secret detected — prompt blocked")

Key Classes

Initialize Client

import { Netallion AI Assurance } from '@netallion/sdk';

const cf = new Netallion AI Assurance({
  apiKey: process.env.NETALLION_API_KEY!,
  // baseUrl: 'https://api.netallion.ai', // default
});

List & Manage Incidents

// List critical open incidents
const incidents = await cf.incidents.list({
  severity: ['critical', 'high'],
  status: 'open',
  page: 1,
  pageSize: 25,
});

console.log(`${incidents.total} open incidents`);

// Acknowledge an incident
await cf.incidents.acknowledge(incidents.items[0].id);

// Get incident details with remediation options
const detail = await cf.incidents.get(incidentId);
console.log(detail.remediation_options);

Trigger Remediation

// Preview blast radius before remediating
const blast = await cf.remediation.blastRadius(incidentId);
console.log(`Affects ${blast.affected_services.length} services`);

// Execute remediation
const result = await cf.remediation.execute({
  incidentId,
  action: 'rotate',  // or 'revoke', 'deactivate'
  confirm: true,
});

// Check status
const status = await cf.remediation.status(incidentId);
console.log(status.state); // 'completed'

// Rollback within 24 hours if needed
await cf.remediation.rollback(incidentId);

Prompt DLP

// Scan an AI prompt before sending
const scan = await cf.promptDlp.scan({
  payload: {
    messages: [
      { role: 'user', content: codeWithPossibleSecrets },
    ],
  },
  provider: 'openai',
  mode: 'redact',
});

if (scan.action === 'blocked') {
  console.error('Prompt contained secrets');
} else if (scan.action === 'redacted') {
  // Use the cleaned payload
  const cleanedPrompt = scan.redacted_payload;
}

// Get prompt DLP stats
const stats = await cf.promptDlp.stats({ days: 30 });

Workspaces & Scans

// List workspaces
const workspaces = await cf.workspaces.list();

// Trigger a scan
const scan = await cf.scans.create({
  workspaceId: workspaces.items[0].id,
});

// Poll scan status
const result = await cf.scans.get(scan.id);
console.log(result.status); // 'completed'
console.log(`Found ${result.findings_count} secrets`);

Available Modules