<!-- Sin npm, sin bundler, compatible con cualquier stack -->
<script src="https://api.anchorum.co/assets/anchorum-sdk.js"></script>

// Sin API Key en el frontend — la key vive en tu servidor backend
const anchorum = new AnchorumClient({
  apiBase: 'https://api.anchorum.co/api/v1'
});

// O con API Key si el frontend es solo tuyo (no público)
const anchorum = new AnchorumClient({
  apiKey: 'anc_tu_api_key'
});

// 1. El usuario selecciona un archivo
const file = document.querySelector('#file-input').files[0];

// 2. El SDK extrae y hashea el documento LOCALMENTE (sin subir el archivo)
const norm = await anchorum.normalizeFile(file, 'anchorum-tree-v3');
// norm = { hash_fisico, hash_robusto, paragraphs: [...], normalize_algo }

// 3. Envía SOLO los hashes a tu backend (archivo nunca sale del navegador)
const r = await fetch('/api/certify', {
  method:  'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    filename:         file.name,
    content:          norm.hash_fisico,
    hash_robusto:     norm.hash_robusto,
    normalize_algo:   norm.normalize_algo,
    paragraph_hashes: norm.paragraphs,
  })
});
// Tu backend llama a Anchorum API con la API Key — Zero-Knowledge garantizado

const seal = await anchorum.certifyFile(file, {
  algorithm: 'anchorum-tree-v3',  // Árbol de Párrafos — detecta cambios por cláusula
  batchId:   'CONTRATOS-ABRIL',     // opcional
  metadata:  { cliente: 'Empresa SA' }  // opcional
});

console.log(seal.document_id);    // UUID del documento
console.log(seal.seal_summary);   // "28 párrafos certificados"
console.log(seal.hash_sha256);    // hash físico
console.log(seal.hash_robusto);   // hash semántico (v2/v3)

const result = await anchorum.verifyFile(file, {
  documentId: '164a0691-5d60-4823-a680-3f8c47b12a91'
});

console.log(result.match);           // true / false
console.log(result.integrity_pct);   // 96.4 (con árbol v3)
console.log(result.algorithm);       // "anchorum-tree-v3"
console.log(result.certified_at);    // "2026-04-19T14:32:00Z"

const diff = await anchorum.diffParagraphs(candidateFile, documentId);

console.log(diff.integrity_pct);        // 88.5
console.log(diff.total_paragraphs);      // 28
console.log(diff.modified_paragraphs);   // 3 (índices de párrafos distintos)
console.log(diff.details[0].index);      // 7 — párrafo #8 modificado
console.log(diff.details[0].match);      // false

const norm = await anchorum.normalizeFile(
  file,
  'anchorum-tree-v3',
  pct => console.log(`Procesando: ${pct}%`)
);

// Retorna:
// norm.hash_fisico      — SHA-256 del archivo binario
// norm.hash_robusto     — hash semántico normalizado
// norm.paragraphs       — array de { index, hash } (v3)
// norm.normalize_algo   — "anchorum-tree-v3"
// norm.paragraph_count  — número de cláusulas detectadas

X-API-Key: anc_TuClaveDe48CaracteresAqui

# En tu evento de firma
def on_document_signed(document_id, file_path, signer):
    # 1. Hash local — el archivo no sale de tu servidor
    with open(file_path, 'rb') as f:
        sha256 = hashlib.sha256(f.read()).hexdigest()

    # 2. Certificar en Anchorum
    r = requests.post('https://api.anchorum.co/api/v1/ingest',
        headers={'X-API-Key': API_KEY},
        json={
            'filename':    os.path.basename(file_path),
            'content':    sha256,
            'batch_id':    f'DOCS-{datetime.today().strftime("%Y-%m")}',
            'metadata':    {'signer': signer, 'doc_id': document_id},
        }, timeout=10)
    r.raise_for_status()

    # 3. Guardar el document_id de Anchorum junto con tu registro
    anchorum_id = r.json()['document_id']
    db.execute(
        'UPDATE documents SET anchorum_id = ? WHERE id = ?',
        (anchorum_id, document_id)
    )

# Tarea cron: cada noche a las 23:00
def nightly_batch_certification():
    today = datetime.today().strftime('%Y-%m-%d')
    batch_id = f'NIGHTLY-{today}'

    # Documentos creados hoy sin certificar
    docs = db.fetch_uncertified_today()

    documents = []
    for doc in docs:
        with open(doc.path, 'rb') as f:
            sha256 = hashlib.sha256(f.read()).hexdigest()
        documents.append({
            'filename':    doc.name,
            'content':    sha256,
            'metadata':    {'internal_id': doc.id},
        })

    # Un solo request certifica hasta 1,000 docs
    r = requests.post('https://api.anchorum.co/api/v1/ingest/batch',
        headers={'X-API-Key': API_KEY},
        json={'batch_id': batch_id, 'documents': documents},
        timeout=30)
    r.raise_for_status()

    # Guardar document_ids y sellar el lote en Bitcoin
    for certified in r.json()['documents']:
        internal_id = certified['metadata']['internal_id']
        db.update_anchorum_id(internal_id, certified['document_id'])

    requests.post('https://api.anchorum.co/api/v1/merkle/generate',
        headers={'X-API-Key': API_KEY},
        json={'batch_id': batch_id})

# Cuando recibes un documento con su document_id de Anchorum
def verify_received_document(file_path, anchorum_document_id):
    with open(file_path, 'rb') as f:
        sha256 = hashlib.sha256(f.read()).hexdigest()

    # Endpoint público — no requiere API Key
    r = requests.get(
        'https://api.anchorum.co/api/v1/verify',
        params={'document_id': anchorum_document_id, 'hash_to_verify': sha256}
    )
    result = r.json()

    if not result['is_valid']:
        raise SecurityError('Documento alterado — rechazando recepción')

    return result['certified_at'], result['ots_verified']

# server.py — proxy mínimo (Python stdlib, sin dependencias)
import http.server, urllib.request, urllib.parse, os

API_KEY  = os.environ['ANCHORUM_API_KEY']   # ← de variable de entorno, nunca hardcoded
API_BASE = 'https://api.anchorum.co/api/v1'

ROUTES = {
    '/proxy/ingest':     '/ingest',
    '/proxy/verify':     '/verify',
    '/proxy/normalize':  '/normalize',
    '/proxy/verify/diff': '/verify/diff',
}

class ProxyHandler(http.server.SimpleHTTPRequestHandler):
    def do_POST(self):
        route = ROUTES.get(urllib.parse.urlparse(self.path).path)
        if not route:
            return self.send_error(404)
        length = int(self.headers.get('Content-Length', 0))
        body   = self.rfile.read(length)
        req    = urllib.request.Request(API_BASE + route, data=body, method='POST')
        req.add_header('Content-Type', self.headers.get('Content-Type', 'application/json'))
        req.add_header('X-API-Key', API_KEY)
        try:
            with urllib.request.urlopen(req, timeout=30) as r:
                data, status = r.read(), r.status
        except urllib.error.HTTPError as e:
            data, status = e.read(), e.code
        self.send_response(status)
        self.send_header('Content-Type', 'application/json')
        self.send_header('Access-Control-Allow-Origin', '*')
        self.end_headers()
        self.wfile.write(data)

# Arrancar: ANCHORUM_API_KEY=anc_... python server.py
import socketserver
with socketserver.TCPServer(('', 8080), ProxyHandler) as s:
    s.serve_forever()

{
  "document_id":    "164a0691-5d60-4823-a680-3f8c47b12a91",
  "filename":       "contrato_compraventa.pdf",
  "hash_sha256":    "a252a71c9d2e8f5c3b1d4e6f7a8b9c0d...",
  "hash_robusto":   "0da3ab97aa4b36174b373a1b785e8180...",
  "seal_type":      "dual",
  "certified_at":   "2026-04-09T14:32:11.847Z",
  "batch_id":       "CONTRATOS-2026-04",
  "status":         "certified",
  "certificate_url":"https://api.anchorum.co/api/v1/certificate/164a0691..."
}

{
  "batch_id":  "AUDITORIA-Q1-2026",
  "certified": 2,
  "failed":    0,
  "documents": [
    {
      "document_id": "uuid-1...",
      "filename":    "reporte_financiero.pdf",
      "certified_at":"2026-04-09T14:32:11Z",
      "status":      "certified"
    }
  ]
}

{
  "total":  127,
  "limit":  50,
  "offset": 0,
  "items": [
    {
      "document_id":  "164a0691-...",
      "filename":     "contrato.pdf",
      "hash_sha256":  "a252a71c...",
      "certified_at": "2026-04-09T14:32:11Z",
      "batch_id":     "CONTRATOS-2026-04",
      "status":       "confirmed"
    }
  ]
}

{
  "batches": [
    {
      "batch_id":         "CONTRATOS-2026-04",
      "doc_count":        23,
      "latest_at":        "2026-04-09T14:32:11Z",
      "ots_status":       "confirmed",
      "merkle_root":      "9f8e7d6c..."
    }
  ]
}

{
  "batch_id":            "CONTRATOS-2026-04",
  "root_hash":           "9f8e7d6c5b4a3f2e...",
  "document_count":      23,
  "ots_status":          "pending",
  "estimated_confirmation": "1-3 horas"
}

{
  "hash_fisico":       "a252a71c9d2e8f5c...",  // SHA-256 del archivo binario
  "hash_robusto":      "0da3ab97aa4b3617...",  // Merkle Root (v3) o SHA-256 normalizado (v2)
  "hash_plano":        "722089ab354404b0...",  // SHA-256 con whitespace colapsado — cross-format
  "normalize_algo":    "anchorum-tree-v3",
  "doc_format":        "pdf",
  "text_length":       18432,
  "normalized_length": 17901,
  "paragraph_count":   28,              // solo v3
  "tree_depth":        5,               // solo v3
  "paragraphs": [                          // solo v3
    {
      "index":        0,
      "hash":         "e3b0c44298fc1c14...",
      "char_count":   412,
      "anchor_start": "CONTRATO DE PRESTACION DE SERVICIOS",
      "anchor_end":   "las partes suscriben el presente",
      "section":      "CLÁUSULA PRIMERA"
    }
  ],
  "warning": null                          // "PDF escaneado" si no hay texto extraíble
}

curl -s -X POST "https://api.anchorum.co/api/v1/normalize?algo=anchorum-tree-v3" \
  -H "X-API-Key: anc_tu_api_key" \
  -F "file=@contrato.pdf" | jq .paragraphs

import hashlib, requests

# 1. Hash físico local
with open("contrato.pdf", "rb") as f:
    file_bytes = f.read()
hash_fisico = hashlib.sha256(file_bytes).hexdigest()

# 2. Extraer árbol de párrafos (server-side)
norm = requests.post(
    "https://api.anchorum.co/api/v1/normalize",
    params={"algo": "anchorum-tree-v3"},
    headers={"X-API-Key": "anc_tu_api_key"},
    files={"file": ("contrato.pdf", file_bytes, "application/pdf")},
).json()

# 3. Certificar con ambos hashes + árbol de párrafos
requests.post(
    "https://api.anchorum.co/api/v1/ingest",
    headers={"X-API-Key": "anc_tu_api_key", "Content-Type": "application/json"},
    json={
        "content":          hash_fisico,
        "filename":         "contrato.pdf",
        "batch_id":         "CONTRATOS-2026-04",
        "hash_robusto":     norm["hash_robusto"],    # Merkle Root
        "normalize_algo":   "anchorum-tree-v3",
        "paragraph_hashes": norm["paragraphs"],     # array de {index, hash, ...}
    },
)

// Crítico: garantiza separación de palabras cuando el PDF no incluye espacio explícito
if (pageText.length > 0 && item.str.length > 0) {
  const lastChar  = pageText[pageText.length - 1];
  const firstChar = item.str[0];
  if (!/\s/.test(lastChar) && !/\s/.test(firstChar)) pageText += ' ';
}
pageText += item.str;
if (item.hasEOL) pageText += '\n';

// Spec v2.1 — debe ser idéntico al pipeline Python de sello_dual_service.py
function _normalizeBase(text) {
  return text
    .normalize('NFKC')                                              // paso 1: ligaduras + compatibilidad
    .replace(/[​‌‍­⁠�]/g, '') // paso 2: invisibles
    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, '')       // paso 3: C0+C1
    .replace(/[\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, '')      // paso 4: bidi
    .replace(/[  -   　]/g, ' ')      // paso 5: espacios Unicode
    .replace(/[ \t]+/g, ' ')                                        // colapsar espacios
    .replace(/^ +| +$/gm, '')                                       // trim por línea
    .replace(/\n{3,}/g, '\n\n')                                     // colapsar newlines
    .trim();
}

function normalizeV2(text) {
  let t = _normalizeBase(text);
  t = t.toLowerCase();                                              // paso 6: lowercase
  t = t.normalize('NFD')
       .replace(/[\u0300-\u036f]/g, '')                            // paso 7: diacríticos
       .normalize('NFC');
  t = t.replace(/^\s*\d+\s*$/gm, '');                             // paso 9: números de página
  return t.trim();
}

async function computeHashRobusto(text) {
  const encoded = new TextEncoder().encode(normalizeV2(text));
  const hashBuf = await crypto.subtle.digest('SHA-256', encoded);
  return Array.from(new Uint8Array(hashBuf))
    .map(b => b.toString(16).padStart(2, '0')).join('');
}

{
  "is_valid":       true,
  "match_type":     "CONTENT_ONLY",
  "document_id":    "164a0691-5d60-4823-a680-3f8c47b12a91",
  "filename":       "contrato_compraventa.pdf",
  "certified_at":   "2026-04-09T14:32:11Z",
  "batch_id":       "CONTRATOS-2026-04",
  "status":         "merkle_anchored",
  "hash_provided":  "e865e288...",
  "hash_stored":    "a252a71c...",
  "verified_at":    "2026-04-15T05:32:04Z",
  "failure_reason": null
}

{
  "document_id":          "164a0691-5d60-4823-...",
  "is_valid":             false,
  "integrity_pct":        92.8,
  "total_paragraphs":     28,
  "intact_paragraphs":    26,
  "modified_paragraphs":  2,
  "details": [
    {
      "index":        3,
      "status":       "modified",    // "intact" | "modified" | "added" | "removed"
      "anchor_start": "CLÁUSULA CUARTA"
    }
  ],
  "summary": "⚠️ Integridad 92.8% — 26/28 párrafos intactos. Cambios en párrafos #4, #17."
}

# 1. Obtener párrafos del candidato
NORM=$(curl -s -X POST "https://api.anchorum.co/api/v1/normalize?algo=anchorum-tree-v3" \
  -F "file=@contrato_v2.pdf" | jq .paragraphs)

# 2. Comparar contra el documento certificado
curl -s -X POST https://api.anchorum.co/api/v1/verify/diff \
  -H "Content-Type: application/json" \
  -d "{
    "document_id": "164a0691-5d60-4823-a680-3f8c47b12a91",
    "candidate_paragraphs": $NORM
  }" | jq .summary

{
  "batch_id":          "CONTRATOS-2026-04",
  "ots_status":        "confirmed",
  "root_hash":         "9f8e7d6c...",
  "bitcoin_block":     890123,
  "bitcoin_block_time":"2026-04-09T15:00:00Z",
  "document_count":    23
}

# Descargar el .ots individual del documento
curl -OJ "https://api.anchorum.co/api/v1/documents/164a0691-5d60-4823-a680-3f8c47b12a91/proof"
# Descarga: contrato_compraventa.ots

# Verificar contra Bitcoin (opentimestamps-client)
ots verify contrato_compraventa.ots contrato_compraventa.pdf
# Success! Bitcoin block 890123 attests data existed as of 2026-04-09T15:00:00Z

import hashlib, requests, time

API_KEY = "anc_tu_api_key"
HEADERS = {"X-API-Key": API_KEY, "Content-Type": "application/json"}

# 1. Calcular hash localmente
with open("contrato.pdf", "rb") as f:
    sha256 = hashlib.sha256(f.read()).hexdigest()

# 2. Certificar
r = requests.post("https://api.anchorum.co/api/v1/ingest", headers=HEADERS, json={
    "filename": "contrato.pdf", "content": sha256, "batch_id": "Q2-2026"
})
doc_id = r.json()["document_id"]  # guardar en tu BD

# 3. Sellar el lote en Bitcoin
requests.post("https://api.anchorum.co/api/v1/merkle/generate", headers=HEADERS,
             json={"batch_id": "Q2-2026"})

# 4. Esperar confirmación (webhook recomendado, o polling)
# En producción usa webhooks. Este es solo un ejemplo de polling:
for _ in range(20):
    status = requests.get(
        f"https://api.anchorum.co/api/v1/ots/Q2-2026/status", headers=HEADERS
    ).json()["ots_status"]
    if status == "confirmed": break
    time.sleep(300)  # esperar 5 minutos entre intentos

# Nota: Si llamas a este endpoint antes de que Bitcoin confirme el lote,
# recibirás HTTP 425 OTS_NOT_READY. Por eso usamos el webhook o polling antes.
# 5. Descargar .ots individual del documento
proof = requests.get(
    f"https://api.anchorum.co/api/v1/documents/{doc_id}/proof", headers=HEADERS
)
with open("contrato.ots", "wb") as f:
    f.write(proof.content)

print("✅ contrato.ots listo para verificar en opentimestamps.org")

{
  "plan":                  "starter",
  "billing_model":         "quota",
  "seals_used":            127,
  "seals_limit":           500,
  "plan_expires_at":       "2026-05-09T23:59:59Z",
  "credits_balance":       null,
  "monthly_history": [
    { "period": "2026-04", "seals": 127 }
  ]
}

{
  "checkout_url": "https://pay.cryptomus.com/pay/uuid...",
  "amount_usd":   20,
  "plan":         "starter"
}

{
  "new_api_key":  "anc_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "message":     "API Key rotada. La anterior ha sido invalidada de inmediato. Guarda esta key — no la volveremos a mostrar. También te la enviamos por email.",
  "client_name": "Tu Empresa"
}

curl -X POST https://api.anchorum.co/api/v1/auth/rotate \
     -H "X-API-Key: anc_tu_key_actual"

{
  "total_documents":   4821,
  "confirmed_batches": 138,
  "active_clients":    47
}

curl https://api.anchorum.co/api/v1/stats

// Request — NO incluyas ningún "secret"
POST /webhooks
{
  "url":    "https://tuservidor.com/webhooks/anchorum",
  "events": ["ots.confirmed"]
}

{
  "id":             "wh_a1b2c3d4...",
  "url":            "https://tuservidor.com/webhooks/anchorum",
  "events":         ["ots.confirmed"],
  "signing_secret": "ancs_xxxxxxxxxxxxxxxx",
  "batch_id":       null,
  "created_at":     "2026-04-15T12:00:00Z"
}
// ↑ Guarda signing_secret — solo se muestra aquí, nunca más.

{
  "event":           "ots.confirmed",
  "batch_id":        "CONTRATOS-2026-04",
  "root_hash":       "9f8e7d6c...",
  "confirmed_at":    "2026-04-09T15:00:00Z",
  "verify_command":  "ots verify -d 9f8e7d6c... anchorum_CONTRATOS-2026-04_merkle.ots"
}

# Instalar cliente OTS
pip install opentimestamps-client

# Descargar el .ots individual del documento
curl -OJ "https://api.anchorum.co/api/v1/documents/164a0691-5d60-4823-a680-3f8c47b12a91/proof"
# Descarga: contrato.ots
ots verify contrato.ots contrato.pdf
# Success! Bitcoin block 890123 attests data existed as of 2026-04-09T15:00:00Z

# Verificar sin API Key ni cuenta
SHA=$(sha256sum mi_contrato.pdf | awk '{print $1}')

curl "https://api.anchorum.co/api/v1/verify?\
document_id=164a0691-5d60-4823-a680-3f8c47b12a91&\
hash_to_verify=$SHA" | jq .

# Respuesta:
# { "is_valid": true, "ots_verified": true, "bitcoin_block": 890123 }