PDF Verification API

# Step 1: Submit PDF for analysis
curl -X POST https://htpbe.tech/api/v1/analyze \
  -H "Authorization: Bearer htpbe_live_..." \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/document.pdf"}'
# Returns: {"id":"3f9c8b7a-2e1d-4c5f-9b8e-7a6d5c4b3a21"}

# Step 2: Retrieve full results
ID="3f9c8b7a-2e1d-4c5f-9b8e-7a6d5c4b3a21"
curl -s "https://htpbe.tech/api/v1/result/$ID" \
  -H "Authorization: Bearer htpbe_live_..." \
  | jq '.status'

// Step 1: Submit PDF for analysis — returns only { id }
async function analyzePDF(fileUrl: string): Promise<string> {
  const response = await fetch('https://htpbe.tech/api/v1/analyze', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.HTPBE_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ url: fileUrl })
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API error: ${error.error}`);
  }

  const { id } = await response.json();
  return id;
}

// Step 2: Retrieve full results by ID
async function getResult(id: string) {
  const response = await fetch(`https://htpbe.tech/api/v1/result/${id}`, {
    headers: { 'Authorization': `Bearer ${process.env.HTPBE_API_KEY}` }
  });
  return response.json();
}

// Usage
const id = await analyzePDF('https://example.com/contract.pdf');
const result = await getResult(id);

switch (result.status) {
  case 'modified':
    console.log('Document has been modified!');
    console.log(`Markers: ${result.modification_markers.join(', ')}`);
    break;
  case 'inconclusive':
    if (result.status_reason === 'online_editor_origin') {
      console.log('Cannot verify — processed through online editor');
    } else if (result.status_reason === 'scanned_document') {
      console.log('Cannot verify — scanned document (no text layer)');
    } else {
      console.log('Cannot verify — created with consumer software');
    }
    console.log(`Origin: ${result.origin.type}, software: ${result.origin.software}`);
    break;
  case 'intact':
    console.log('Document is intact');
    break;
}

import requests
import os
from typing import Dict, Any

class HTPBEClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://htpbe.tech/api/v1'

    def analyze(self, url: str) -> str:
        """Submit PDF for analysis, returns check ID"""
        response = requests.post(
            f'{self.base_url}/analyze',
            headers={
                'Authorization': f'Bearer {self.api_key}',
                'Content-Type': 'application/json'
            },
            json={'url': url}
        )
        response.raise_for_status()
        return response.json()['id']

    def get_result(self, check_id: str) -> Dict[str, Any]:
        """Retrieve full analysis result"""
        response = requests.get(
            f'{self.base_url}/result/{check_id}',
            headers={'Authorization': f'Bearer {self.api_key}'}
        )
        response.raise_for_status()
        return response.json()

# Initialize client
client = HTPBEClient(os.getenv('HTPBE_API_KEY'))

# Two-step analysis
check_id = client.analyze('https://example.com/contract.pdf')
result = client.get_result(check_id)

# Check results
if result['status'] == 'modified':
    print("Document has been modified!")
    print("\nMarkers:")
    for marker in result['modification_markers']:
        print(f"  • {marker}")
elif result['status'] == 'inconclusive':
    reason = result.get('status_reason', '')
    if reason == 'online_editor_origin':
        print("Cannot verify — processed through online editor")
    elif reason == 'scanned_document':
        print("Cannot verify — scanned document (no text layer)")
    else:
        print("Cannot verify — created with consumer software")
else:
    print("Document appears to be original")

<?php

function analyzePDF($fileUrl, $apiKey) {
    // Step 1: Submit for analysis
    $ch = curl_init('https://htpbe.tech/api/v1/analyze');
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            'Authorization: Bearer ' . $apiKey,
            'Content-Type: application/json'
        ],
        CURLOPT_POSTFIELDS => json_encode(['url' => $fileUrl])
    ]);
    $response = curl_exec($ch);
    curl_close($ch);

    $data = json_decode($response, true);
    $checkId = $data['id'];

    // Step 2: Retrieve full result
    $ch = curl_init("https://htpbe.tech/api/v1/result/{$checkId}");
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey]
    ]);
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode !== 200) {
        throw new Exception("API request failed: " . $response);
    }

    return json_decode($response, true);
}

// Usage
$result = analyzePDF(
    'https://example.com/contract.pdf',
    getenv('HTPBE_API_KEY')
);

if ($result['status'] === 'modified') {
    echo "Document modified!\n";
    echo "Markers: " . implode(", ", $result['modification_markers']) . "\n";
} elseif ($result['status'] === 'inconclusive') {
    $reason = $result['status_reason'];
    if ($reason === 'online_editor_origin') {
        echo "Cannot verify — processed through online editor\n";
    } elseif ($reason === 'scanned_document') {
        echo "Cannot verify — scanned document (no text layer)\n";
    } else {
        echo "Cannot verify — created with consumer software\n";
    }
} else {
    echo "Document is original\n";
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type AnalyzeRequest struct {
    FileURL string `json:"url"`
}

type AnalyzeResponse struct {
    ID string `json:"id"`
}

type AnalysisResult struct {
    Status              string   `json:"status"`
    ModificationMarkers []string `json:"modification_markers"`
}

func submitAnalysis(fileURL, apiKey string) (string, error) {
    reqBody, _ := json.Marshal(AnalyzeRequest{FileURL: fileURL})

    req, _ := http.NewRequest("POST",
        "https://htpbe.tech/api/v1/analyze",
        bytes.NewBuffer(reqBody))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var data AnalyzeResponse
    json.Unmarshal(body, &data)
    return data.ID, nil
}

func getResult(id, apiKey string) (*AnalysisResult, error) {
    req, _ := http.NewRequest("GET",
        "https://htpbe.tech/api/v1/result/"+id, nil)
    req.Header.Set("Authorization", "Bearer "+apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result AnalysisResult
    json.Unmarshal(body, &result)
    return &result, nil
}

func main() {
    apiKey := os.Getenv("HTPBE_API_KEY")

    id, err := submitAnalysis("https://example.com/contract.pdf", apiKey)
    if err != nil {
        panic(err)
    }

    result, err := getResult(id, apiKey)
    if err != nil {
        panic(err)
    }

    switch result.Status {
    case "modified":
        fmt.Println("Modified!")
        for _, m := range result.ModificationMarkers {
            fmt.Println(" •", m)
        }
    case "inconclusive":
        fmt.Println("Cannot verify — consumer software, online editor, or scanned origin")
    default:
        fmt.Println("Original document")
    }
}

require 'net/http'
require 'json'
require 'uri'

class HTPBEClient
  def initialize(api_key)
    @api_key = api_key
    @base_url = 'https://htpbe.tech/api/v1'
  end

  def analyze(url)
    uri = URI("#{@base_url}/analyze")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Post.new(uri.path)
    request['Authorization'] = "Bearer #{@api_key}"
    request['Content-Type'] = 'application/json'
    request.body = { url: url }.to_json

    response = http.request(request)
    JSON.parse(response.body)['id']
  end

  def get_result(check_id)
    uri = URI("#{@base_url}/result/#{check_id}")
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Get.new(uri.path)
    request['Authorization'] = "Bearer #{@api_key}"

    response = http.request(request)
    JSON.parse(response.body)
  end
end

# Usage
client = HTPBEClient.new(ENV['HTPBE_API_KEY'])
check_id = client.analyze('https://example.com/contract.pdf')
result = client.get_result(check_id)

if result['status'] == 'modified'
  puts "Document modified!"
  puts "Markers: #{result['modification_markers'].join(', ')}"
elsif result['status'] == 'inconclusive'
  puts "Cannot verify — consumer software, online editor, or scanned origin"
else
  puts "Document is original"
end