pip install compliancelayer

from compliancelayer import ComplianceLayer

# Initialize the client with your API key
client = ComplianceLayer(api_key="cl_your_api_key_here")

# Run a scan and wait for results
report = client.scan("example.com")

# Access the results
print(f"{report.domain}: {report.grade} ({report.score}/100)")
print(f"Risk level: {report.risk_level}")
print(f"Issues found: {report.issues_count}")

# Iterate over findings
for issue in report.issues:
    print(f"  [{issue.severity}] {issue.finding}")
    if issue.remediation:
        print(f"    Fix: {issue.remediation}")

import asyncio
from compliancelayer import AsyncComplianceLayer

async def main():
    # Use as async context manager for automatic cleanup
    async with AsyncComplianceLayer(api_key="cl_your_api_key") as client:
        # Run a scan
        report = await client.scan("example.com")
        print(f"{report.domain}: {report.grade} ({report.score}/100)")

        # Run multiple scans concurrently
        domains = ["example.com", "acme.org", "globex.net"]
        tasks = [client.scan(domain) for domain in domains]
        reports = await asyncio.gather(*tasks)

        for report in reports:
            print(f"{report.domain}: {report.grade}")

asyncio.run(main())

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

# Submit batch scan
batch = client.batch_scan(domains)
print(f"Batch ID: {batch.batch_id}")
print(f"Total domains: {batch.total}")

# Wait for all scans to complete
batch.wait()

# Access individual results
for result in batch.results:
    print(f"{result.domain}: {result.grade} ({result.score}/100)")

# Get summary statistics
print(f"Average score: {batch.average_score}")
print(f"Completed: {batch.completed_count}/{batch.total}")
print(f"Failed: {batch.failed_count}")

# Compare security posture across domains
comparison = client.compare([
    "example.com",
    "competitor1.com",
    "competitor2.com"
])

# Overall comparison
print(f"Best: {comparison.best.domain} ({comparison.best.score})")
print(f"Worst: {comparison.worst.domain} ({comparison.worst.score})")
print(f"Average: {comparison.average_score}")

# Module-level comparison
for module_name, scores in comparison.by_module.items():
    print(f"\n{module_name}:")
    for domain, score in scores.items():
        print(f"  {domain}: {score}/100")

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

print(f"Webhook ID: {webhook.id}")
print(f"Secret: {webhook.secret}")  # Shown only once!
print(f"Status: {webhook.status}")  # "active"

# Add a domain to monitoring
domain = client.domains.add(
    domain="example.com",
    scan_interval="weekly",    # "daily", "weekly", "monthly"
    alert_threshold=70         # Alert if score drops below this
)

print(f"Domain ID: {domain.id}")
print(f"Monitoring: {domain.domain}")
print(f"Scan interval: {domain.scan_interval}")
print(f"Next scan: {domain.next_scan_at}")

# Get the badge URL for a domain
url = client.badge_url("example.com")
print(f"Badge URL: {url}")
# https://api.compliancelayer.net/v1/badge/example.com

# Use in Markdown
markdown = f"![Security Score]({url})"
print(markdown)

# Get the raw SVG content
svg = client.badge_svg("example.com")
with open("badge.svg", "w") as f:
    f.write(svg)

# Customize badge style
url = client.badge_url(
    "example.com",
    style="flat",        # "flat", "flat-square", "plastic"
    label="Security"     # Custom left-side label
)

from compliancelayer import ComplianceLayer

# Fully customized client
client = ComplianceLayer(
    api_key="cl_your_api_key",
    base_url="https://api.compliancelayer.net/v1",
    timeout=60.0,          # 60s HTTP timeout
    poll_interval=3.0,     # Poll every 3 seconds
    poll_timeout=180.0,    # Wait up to 3 minutes for scans
    max_retries=5          # Retry up to 5 times on failures
)

# Or use environment variable for API key
# export COMPLIANCELAYER_API_KEY=cl_your_api_key
client = ComplianceLayer()  # Reads from env

from compliancelayer import ComplianceLayer
from compliancelayer.exceptions import (
    ComplianceLayerError,    # Base exception 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
)

client = ComplianceLayer(api_key="cl_your_api_key")

try:
    report = client.scan("example.com")
    print(f"Score: {report.score}")

except AuthenticationError:
    print("Invalid API key. Check your credentials.")

except QuotaExceededError as e:
    print(f"Scan quota exhausted. Resets at: {e.reset_at}")
    print(f"Current usage: {e.used}/{e.limit}")

except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds.")

except ScanTimeoutError:
    print("Scan took too long. Try again or increase poll_timeout.")

except ScanFailedError as e:
    print(f"Scan failed: {e.reason}")
    print(f"Domain: {e.domain}")

except ValidationError as e:
    print(f"Invalid input: {e.detail}")
    for error in e.errors:
        print(f"  Field '{error['field']}': {error['message']}")

except ServerError:
    print("ComplianceLayer server error. Try again later.")

except ConnectionError:
    print("Network error. Check your internet connection.")

except ComplianceLayerError as e:
    # Catch-all for any SDK error
    print(f"Unexpected error: {e}")

import httpx
from compliancelayer import ComplianceLayer

# Custom HTTP client with proxy and TLS settings
http_client = httpx.Client(
    proxy="http://proxy.corp.example.com:8080",
    verify="/path/to/custom/ca-bundle.crt",
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10
    )
)

client = ComplianceLayer(
    api_key="cl_your_api_key",
    http_client=http_client
)

import logging

# Enable debug logging for the SDK
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger("compliancelayer")
logger.setLevel(logging.DEBUG)

# Now all API requests will be logged:
# DEBUG:compliancelayer:POST /v1/scan {"domain": "example.com"}
# DEBUG:compliancelayer:200 OK (234ms)
# DEBUG:compliancelayer:GET /v1/scan/jobs/12345
# DEBUG:compliancelayer:200 OK {"status": "completed", ...}

# Automatic pagination - iterates through all pages
for domain in client.domains.list():
    print(f"{domain.domain}: {domain.latest_score}")

# Manual pagination with page size control
page = client.domains.list(limit=25)
print(f"Total domains: {page.total}")
print(f"Page 1 of {page.total_pages}")

for domain in page.items:
    print(f"  {domain.domain}")

# Get next page
if page.has_next:
    next_page = page.next()

from compliancelayer.webhooks import verify_signature

# In your Flask/FastAPI/Django webhook handler
def handle_webhook(request):
    payload = request.get_data(as_text=True)
    signature = request.headers.get("X-ComplianceLayer-Signature")
    secret = "whsec_your_webhook_secret"

    # Verify the signature (raises InvalidSignatureError if invalid)
    verify_signature(payload, signature, secret)

    # Safe to process the event
    event = json.loads(payload)
    print(f"Event: {event['type']}")