POST /tu-endpoint-webhook
Content-Type: application/json
Authorization: Bearer [TU-AUTH-KEY]
User-Agent: JAAK-Webhook/1.0

{
  "event": "kyc.session.completed",
  "timestamp": "2024-01-15T10:30:00Z",
  "sessionId": "ABC123X",
  "data": {
    "status": "APPROVED",
    "confidence": 95.5,
    "user": {
      "name": "María González Pérez",
      "documentNumber": "ABCD123456789",
      "dateOfBirth": "1990-05-15",
      "nationality": "MEX"
    },
    "document": {
      "type": "INE",
      "country": "MEX",
      "isValid": true,
      "expirationDate": "2029-05-15"
    },
    "validation": {
      "documentAuthenticity": "PASS",
      "faceMatch": "PASS",
      "liveness": "PASS"
    }
  }
}

from flask import Flask, request, jsonify
import json

app = Flask(__name__)

# Tu Auth Key configurada en JAAK
AUTH_KEY = "JK2024-webhook-Auth-789XYZ"

@app.route('/webhook/kyc', methods=['POST'])
def webhook_kyc():
    # Verificar autenticación
    auth_header = request.headers.get('Authorization', '')
    if not auth_header.startswith('Bearer '):
        return jsonify({"error": "Missing authorization"}), 401
    
    received_key = auth_header.replace('Bearer ', '')
    if received_key != AUTH_KEY:
        return jsonify({"error": "Invalid auth key"}), 401
    
    # Procesar datos
    try:
        data = request.get_json()
        
        # Extraer información importante
        session_id = data.get('sessionId')
        status = data['data']['status']
        user_name = data['data']['user']['name']
        
        print(f"KYC Completado - Sesión: {session_id}")
        print(f"Usuario: {user_name}")
        print(f"Estado: {status}")
        
        # Aquí añades tu lógica de negocio
        process_kyc_result(data)
        
        return jsonify({"received": True}), 200
        
    except Exception as e:
        print(f"Error procesando webhook: {e}")
        return jsonify({"error": "Processing failed"}), 500

def process_kyc_result(data):
    """Tu lógica personalizada aquí"""
    status = data['data']['status']
    
    if status == "APPROVED":
        # Cliente aprobado - activar cuenta, enviar bienvenida, etc.
        activate_user_account(data['data']['user'])
    elif status == "REJECTED":
        # Cliente rechazado - enviar instrucciones, solicitar documentos, etc.
        handle_rejection(data['sessionId'])
    elif status == "PENDING":
        # Revisión manual requerida - notificar equipo de compliance
        notify_manual_review(data['sessionId'])

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=443, ssl_context='adhoc')

const express = require('express');
const app = express();

// Tu Auth Key configurada en JAAK
const AUTH_KEY = "JK2024-webhook-Auth-789XYZ";

app.use(express.json());

app.post('/webhook/kyc', (req, res) => {
    // Verificar autenticación
    const authHeader = req.headers.authorization || '';
    if (!authHeader.startsWith('Bearer ')) {
        return res.status(401).json({ error: 'Missing authorization' });
    }
    
    const receivedKey = authHeader.replace('Bearer ', '');
    if (receivedKey !== AUTH_KEY) {
        return res.status(401).json({ error: 'Invalid auth key' });
    }
    
    try {
        const data = req.body;
        
        // Extraer información importante
        const sessionId = data.sessionId;
        const status = data.data.status;
        const userName = data.data.user.name;
        
        console.log(`KYC Completado - Sesión: ${sessionId}`);
        console.log(`Usuario: ${userName}`);
        console.log(`Estado: ${status}`);
        
        // Tu lógica de negocio aquí
        processKycResult(data);
        
        res.status(200).json({ received: true });
        
    } catch (error) {
        console.error('Error procesando webhook:', error);
        res.status(500).json({ error: 'Processing failed' });
    }
});

function processKycResult(data) {
    const status = data.data.status;
    
    switch(status) {
        case 'APPROVED':
            // Cliente aprobado
            activateUserAccount(data.data.user);
            break;
        case 'REJECTED':
            // Cliente rechazado
            handleRejection(data.sessionId);
            break;
        case 'PENDING':
            // Revisión manual
            notifyManualReview(data.sessionId);
            break;
    }
}

app.listen(443, () => {
    console.log('Webhook server running on port 443');
});

<?php
header('Content-Type: application/json');

// Tu Auth Key configurada en JAAK
$AUTH_KEY = "JK2024-webhook-Auth-789XYZ";

// Verificar método HTTP
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    echo json_encode(['error' => 'Method not allowed']);
    exit;
}

// Verificar autenticación
$authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
if (!str_starts_with($authHeader, 'Bearer ')) {
    http_response_code(401);
    echo json_encode(['error' => 'Missing authorization']);
    exit;
}

$receivedKey = str_replace('Bearer ', '', $authHeader);
if ($receivedKey !== $AUTH_KEY) {
    http_response_code(401);
    echo json_encode(['error' => 'Invalid auth key']);
    exit;
}

// Procesar datos
try {
    $input = file_get_contents('php://input');
    $data = json_decode($input, true);
    
    if (!$data) {
        throw new Exception('Invalid JSON');
    }
    
    // Extraer información importante
    $sessionId = $data['sessionId'];
    $status = $data['data']['status'];
    $userName = $data['data']['user']['name'];
    
    error_log("KYC Completado - Sesión: $sessionId");
    error_log("Usuario: $userName");
    error_log("Estado: $status");
    
    // Tu lógica de negocio aquí
    processKycResult($data);
    
    http_response_code(200);
    echo json_encode(['received' => true]);
    
} catch (Exception $e) {
    error_log('Error procesando webhook: ' . $e->getMessage());
    http_response_code(500);
    echo json_encode(['error' => 'Processing failed']);
}

function processKycResult($data) {
    $status = $data['data']['status'];
    
    switch($status) {
        case 'APPROVED':
            // Cliente aprobado
            activateUserAccount($data['data']['user']);
            break;
        case 'REJECTED':
            // Cliente rechazado
            handleRejection($data['sessionId']);
            break;
        case 'PENDING':
            // Revisión manual
            notifyManualReview($data['sessionId']);
            break;
    }
}
?>

HTTP/1.1 200 OK
Content-Type: application/json

{
  "received": true
}

[INFO] POST /webhook/kyc - Autenticación exitosa
[INFO] KYC Completado - Sesión: ABC123X
[INFO] Usuario: Test Webhook
[INFO] Estado: APPROVED
[INFO] Respuesta 200 enviada a JAAK

[ERROR] POST /webhook/kyc - Auth Key inválida
[ERROR] JSON malformado en webhook
[ERROR] Timeout procesando webhook

{
  "event": "kyc.session.completed",
  "timestamp": "2024-07-14T15:30:45Z",
  "sessionId": "ABC123X",
  "data": {
    "status": "APPROVED",
    "confidence": 95.5,
    "processingTime": "45.2",
    "user": {
      "name": "María González Pérez",
      "documentNumber": "GONZ900515MDFRNR08",
      "dateOfBirth": "1990-05-15",
      "nationality": "MEX",
      "gender": "F"
    },
    "document": {
      "type": "INE",
      "country": "MEX",
      "isValid": true,
      "expirationDate": "2029-05-15",
      "issueDate": "2019-05-15"
    },
    "validation": {
      "documentAuthenticity": "PASS",
      "faceMatch": "PASS",
      "liveness": "PASS",
      "blacklistCheck": "PASS"
    },
    "scores": {
      "documentQuality": 98.2,
      "faceMatchScore": 94.7,
      "livenessScore": 96.1,
      "overallConfidence": 95.5
    },
    "metadata": {
      "ipAddress": "192.168.1.100",
      "userAgent": "Mozilla/5.0...",
      "deviceType": "mobile",
      "location": {
        "country": "MX",
        "region": "CDMX",
        "city": "Mexico City"
      }
    }
  }
}

def process_kyc_webhook(data):
    status = data['data']['status']
    confidence = data['data']['confidence']
    validations = data['data']['validation']
    
    if status == "APPROVED":
        if confidence >= 90:
            # Alta confianza - aprobación automática
            auto_approve_user(data)
        elif confidence >= 70:
            # Confianza media - aprobación con monitoreo
            approve_with_monitoring(data)
        else:
            # Baja confianza - revisión manual
            queue_for_manual_review(data)
            
    elif status == "REJECTED":
        # Analizar razones específicas
        if validations['liveness'] == "FAIL":
            request_retry_with_instructions(data, "liveness")
        elif validations['documentAuthenticity'] == "FAIL":
            request_different_document(data)
        else:
            manual_review_required(data)
            
    elif status == "PENDING":
        # Siempre requiere revisión manual
        notify_compliance_team(data)
        
    elif status == "ERROR":
        # Error técnico - permitir reintento
        send_retry_notification(data)

{
  "confidence": 95.0,
  "validation": {
    "documentAuthenticity": "PASS",
    "faceMatch": "FAIL",
    "liveness": "PASS"
  }
}

{
  "confidence": 65.0,
  "validation": {
    "documentAuthenticity": "PASS",
    "faceMatch": "PASS",
    "liveness": "PASS"
  }
}

{
  "metadata": {
    "ipAddress": "192.168.1.100",
    "location": {
      "country": "RU"  // País diferente al esperado
    }
  }
}

import logging
import json

logging.basicConfig(level=logging.DEBUG)

@app.route('/webhook/kyc', methods=['POST'])
def webhook_kyc():
    logger = logging.getLogger(__name__)
    
    # Log headers completos
    logger.debug(f"Headers recibidos: {dict(request.headers)}")
    
    # Log body raw
    raw_data = request.get_data()
    logger.debug(f"Body raw: {raw_data}")
    
    # Log IP origen
    logger.debug(f"IP origen: {request.remote_addr}")
    
    try:
        data = request.get_json()
        logger.info(f"Webhook procesado: {data.get('sessionId')}")
        
        # Log estructura de datos
        logger.debug(f"Estructura completa: {json.dumps(data, indent=2)}")
        
        return jsonify({"received": True}), 200
        
    except Exception as e:
        logger.error(f"Error procesando webhook: {str(e)}", exc_info=True)
        return jsonify({"error": str(e)}), 500

curl -X POST https://tu-servidor.com/webhook/kyc \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer JK2024-webhook-Auth-789XYZ" \
  -d '{
    "event": "kyc.session.completed",
    "timestamp": "2024-07-14T15:30:45Z",
    "sessionId": "TEST123",
    "data": {
      "status": "APPROVED",
      "confidence": 95.5,
      "user": {
        "name": "Test User",
        "documentNumber": "TEST123456789",
        "dateOfBirth": "1990-01-01",
        "nationality": "MEX"
      }
    }
  }'