PDF Authenticity & Tamper Detection API

// Retrieve a specific check result
const checkId = '506a6b1b-1360-48a2-b389-abb346f85d04';

const response = await fetch(
  `https://api.htpbe.tech/v1/result/${checkId}`,
  {
    headers: {
      'Authorization': `Bearer ${API_KEY}`
    }
  }
);

const result = await response.json();

console.log(`File: ${result.filename}`);
console.log(`Status: ${result.status}`);
console.log(`Markers: ${result.modification_markers.join(', ')}`);

import requests
from urllib.parse import quote

# Get all modified PDFs for manual review
response = requests.get(
    'https://api.htpbe.tech/v1/checks',
    params={
        'status': 'modified',
        'limit': 100
    },
    headers={'Authorization': f'Bearer {API_KEY}'}
)

data = response.json()

print(f"Found {data['total']} modified PDFs")
print(f"\nShowing first {len(data['data'])} results:")

for check in data['data'][:5]:
    print(f"\n{check['filename']}")
    print(f"  Tool: {check['creator']} → {check['producer']}")
    print(f"  Review: https://htpbe.tech/result/{check['id']}")

// Build a dashboard from /checks — no extra endpoints needed
async function fetchDashboardData(apiKey: string) {
  const headers = { Authorization: `Bearer ${apiKey}` };

  // Fetch all checks (paginate if needed)
  const checksRes = await fetch(
    'https://api.htpbe.tech/v1/checks?limit=500',
    { headers }
  );
  const { data: checks, total } = await checksRes.json();

  // Calculate metrics from raw data
  const modified = checks.filter((c) => c.status === 'modified').length;
  const toolStats = new Map<string, { count: number; modified: number }>();

  checks.forEach((check) => {
    const tool = check.producer || 'Unknown';
    const current = toolStats.get(tool) || { count: 0, modified: 0 };
    toolStats.set(tool, {
      count: current.count + 1,
      modified: current.modified + (check.status === 'modified' ? 1 : 0)
    });
  });

  return {
    overview: {
      total,
      modified,
      modificationRate: total > 0 ? ((modified / total) * 100).toFixed(1) : '0.0'
    },
    recentModified: checks
      .filter((c) => c.status === 'modified')
      .slice(0, 5)
      .map((c) => ({ filename: c.filename, tool: c.producer })),
    toolBreakdown: Array.from(toolStats.entries())
      .map(([name, data]) => ({
        name,
        count: data.count,
        modificationRate: ((data.modified / data.count) * 100).toFixed(1)
      }))
      .sort((a, b) => b.count - a.count)
  };
}

const dashboardData = await fetchDashboardData(API_KEY);
console.log('Dashboard Data:', JSON.stringify(dashboardData, null, 2));

// Check bank statement before approving a loan application
async function checkBankStatement(statementUrl) {
  // Step 1: Submit for analysis
  const { id } = await fetch('https://api.htpbe.tech/v1/analyze', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + process.env.HTPBE_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ url: statementUrl })
  }).then(r => r.json());

  // Step 2: Get full result
  const result = await fetch(`https://api.htpbe.tech/v1/result/${id}`, {
    headers: { 'Authorization': 'Bearer ' + process.env.HTPBE_API_KEY }
  }).then(r => r.json());

  if (result.status === 'modified') {
    return {
      approved: false,
      reason: 'Bank statement has been modified — do not process application',
      markers: result.modification_markers
    };
  }

  if (result.status === 'inconclusive') {
    return {
      approved: false,
      reason: 'Cannot determine document integrity — manual review required',
      origin: result.origin
    };
  }

  return { approved: true, reason: 'Bank statement is structurally intact' };
}

import asyncio
import aiohttp

async def analyze_bulk(urls: list[str], api_key: str):
    """Analyze multiple PDFs concurrently"""
    headers = {'Authorization': f'Bearer {api_key}'}

    async with aiohttp.ClientSession() as session:
        # Step 1: Submit all PDFs for analysis
        submit_tasks = [
            session.post(
                'https://api.htpbe.tech/v1/analyze',
                headers={**headers, 'Content-Type': 'application/json'},
                json={'url': url}
            )
            for url in urls
        ]
        submit_responses = await asyncio.gather(*submit_tasks)
        ids = [(await r.json())['id'] for r in submit_responses]

        # Step 2: Retrieve all results
        result_tasks = [
            session.get(
                f'https://api.htpbe.tech/v1/result/{id}',
                headers=headers
            )
            for id in ids
        ]
        result_responses = await asyncio.gather(*result_tasks)
        results = [await r.json() for r in result_responses]

        modified_count = sum(1 for r in results if r['status'] == 'modified')
        inconclusive_count = sum(1 for r in results if r['status'] == 'inconclusive')

        return {
            'total': len(results),
            'modified': modified_count,
            'inconclusive': inconclusive_count,
            'intact': len(results) - modified_count - inconclusive_count,
            'details': results
        }

# Process 100 documents in parallel
urls = [f'https://storage.example.com/doc_{i}.pdf' for i in range(100)]
summary = await analyze_bulk(urls, os.getenv('HTPBE_API_KEY'))
print(f"Scanned {summary['total']} docs: {summary['modified']} modified, {summary['inconclusive']} inconclusive, {summary['intact']} intact")

// Automatic tamper check on upload
async function handleDocumentUpload(file: File) {
  // 1. Upload to your storage
  const fileUrl = await uploadToS3(file);

  // 2. Submit for analysis
  const { id } = await fetch('https://api.htpbe.tech/v1/analyze', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${HTPBE_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ url: fileUrl })
  }).then(r => r.json());

  // 3. Retrieve full result
  const result = await fetch(`https://api.htpbe.tech/v1/result/${id}`, {
    headers: { 'Authorization': `Bearer ${HTPBE_API_KEY}` }
  }).then(r => r.json());

  // 4. Store in database with detection status
  await db.documents.create({
    filename: file.name,
    url: fileUrl,
    intact: result.status === 'intact',
    uploaded_at: new Date()
  });

  // 5. Alert if modified
  if (result.status === 'modified') {
    await notifySecurityTeam({
      document: file.name,
      findings: result.modification_markers
    });
  }

  return result;
}