Use Case Guide · Updated February 2026

Legal Compliance: Website Evidence Capture & Archiving

When a website claim becomes a legal dispute, you need proof of what was published and when. Screenshots taken manually are easy to challenge — they lack timestamps, metadata, and chain of custody. Automated evidence capture with timestamped screenshots and PDFs creates a defensible record that holds up in court.

SnapAPI provides the infrastructure to capture, archive, and retrieve website evidence at scale — for legal teams, compliance departments, and regulatory agencies.

Why Legal Teams Need Automated Web Capture

Websites are ephemeral. Content changes, pages disappear, and claims get edited. In legal proceedings, you need to prove what a webpage said at a specific point in time. Common scenarios include:

• Advertising compliance — capturing competitor claims, pricing representations, and disclaimers for FTC/ASA investigations
• Intellectual property — documenting trademark infringement, copyright violations, and counterfeit product listings
• GDPR & CCPA audits — recording cookie consent banners, privacy policies, and data collection practices over time
• Contract disputes — archiving terms of service, SLAs, and product specifications as published
• Employment litigation — capturing social media posts, job listings, and company statements
• Insurance claims — preserving website content before and after incidents

Capture Website Evidence with SnapAPI

Full-Page Screenshot with Timestamp

curl "https://api.snapapi.pics/v1/screenshot?url=https://example.com/terms-of-service&full_page=true&width=1440&format=png" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o evidence_2026-02-19T143200Z.png

PDF Capture for Court Submissions

curl "https://api.snapapi.pics/v1/pdf?url=https://example.com/pricing-page&format=A4&print_background=true" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -o evidence_pricing_2026-02-19.pdf

Python: Automated Compliance Archival System

import requests
import hashlib
import json
from datetime import datetime, timezone

SNAPAPI_KEY = "YOUR_API_KEY"
BASE = "https://api.snapapi.pics/v1"
HEADERS = {"Authorization": f"Bearer {SNAPAPI_KEY}"}

def capture_evidence(url, case_id, evidence_type="screenshot"):
    """Capture a webpage with full metadata for legal records."""
    timestamp = datetime.now(timezone.utc).isoformat()

    # Capture full-page screenshot
    screenshot = requests.get(f"{BASE}/screenshot", params={
        "url": url,
        "width": 1440,
        "full_page": "true",
        "format": "png"  # PNG for lossless evidence
    }, headers=HEADERS)

    # Also capture as PDF for printable records
    pdf = requests.get(f"{BASE}/pdf", params={
        "url": url,
        "format": "A4",
        "print_background": "true"
    }, headers=HEADERS)

    # Extract page metadata
    metadata = requests.get(f"{BASE}/extract", params={
        "url": url
    }, headers=HEADERS).json()

    # Create integrity hash
    screenshot_hash = hashlib.sha256(screenshot.content).hexdigest()
    pdf_hash = hashlib.sha256(pdf.content).hexdigest()

    # Save evidence files
    prefix = f"evidence/{case_id}/{timestamp.replace(':', '-')}"
    with open(f"{prefix}_screenshot.png", "wb") as f:
        f.write(screenshot.content)
    with open(f"{prefix}_document.pdf", "wb") as f:
        f.write(pdf.content)

    # Save evidence manifest
    manifest = {
        "case_id": case_id,
        "url": url,
        "captured_at": timestamp,
        "screenshot_sha256": screenshot_hash,
        "pdf_sha256": pdf_hash,
        "page_title": metadata.get("title"),
        "page_description": metadata.get("description")
    }
    with open(f"{prefix}_manifest.json", "w") as f:
        json.dump(manifest, f, indent=2)

    return manifest

# Schedule daily captures of monitored pages
urls_to_monitor = [
    "https://competitor.com/pricing",
    "https://competitor.com/terms",
    "https://competitor.com/claims",
]

for url in urls_to_monitor:
    result = capture_evidence(url, case_id="CASE-2026-0142")
    print(f"Captured: {result['url']} — SHA256: {result['screenshot_sha256'][:16]}...")

Node.js: GDPR Cookie Consent Monitor

const API_KEY = 'YOUR_API_KEY';
const BASE = 'https://api.snapapi.pics/v1';
const crypto = require('crypto');

async function auditCookieConsent(url) {
  // Capture the page as a first-time visitor sees it (with cookie banner)
  const screenshotRes = await fetch(
    `${BASE}/screenshot?url=${encodeURIComponent(url)}&width=1440&height=900&format=png`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    }
  );

  const screenshot = Buffer.from(await screenshotRes.arrayBuffer());
  const hash = crypto.createHash('sha256').update(screenshot).digest('hex');

  return {
    url,
    capturedAt: new Date().toISOString(),
    screenshotSize: screenshot.length,
    sha256: hash,
    screenshot
  };
}

// Audit multiple domains for GDPR compliance
const domains = [
  'https://your-site.com',
  'https://your-site.de',
  'https://your-site.fr',
];

for (const domain of domains) {
  const result = await auditCookieConsent(domain);
  console.log(`Audited ${domain}: ${result.sha256.slice(0, 16)}...`);
}

Key Benefits for Legal & Compliance Teams

Industries That Use Web Evidence Capture

• Law firms — preserve opposing party's web content before it changes during discovery
• Brand protection agencies — document trademark and copyright infringement at scale
• Financial regulators — archive fintech and crypto marketing claims for compliance review
• Insurance companies — capture claimant's online presence and stated conditions
• Pharmaceutical compliance — monitor drug advertising claims and required disclaimers
• E-commerce brands — capture unauthorized reseller pricing for MAP enforcement

FAQ

Are SnapAPI screenshots admissible as legal evidence?

SnapAPI provides the technical capture infrastructure — timestamped screenshots, PDFs, and SHA-256 hashes for integrity verification. Admissibility depends on your jurisdiction and how you maintain chain of custody. Many legal teams use API captures alongside notarization services for maximum defensibility.

Can I capture pages that require login?

SnapAPI captures publicly accessible pages. For authenticated content, you can pass cookies or session tokens via the API. Check the API documentation for authentication options.

How long are captures stored?

SnapAPI returns captures directly — you store them in your own systems. This gives you full control over retention policies, which is important for compliance frameworks like GDPR.

Can I capture pages in different languages/locations?

Yes. Set custom headers including Accept-Language to capture localized versions of pages, which is critical for multi-jurisdiction compliance monitoring.

Related: Web Archiving · E-commerce Monitoring · PDF Generation · Free Screenshot API Guide · API Documentation