Aeglis API Reference

Authorization: Bearer sk_live_YOUR_SECRET_KEY

curl -X POST https://api.aeglis.com/v3/api/scan \
  -H "Authorization: Bearer sk_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "input_text": "Claim your free airdrop here: http://crypto-scam.xyz",
    "user_id": "usr_8923"
  }'

{
  "status": "success",
  "data": {
    "risk_level": "DANGER",
    "reason": "Context AI match: Known phishing domain and social engineering attempt detected."
  }
}

curl -X POST https://api.aeglis.com/v3/api/deep-scan \
  -H "Authorization: Bearer sk_live_your_key" \
  -F "file=@/path/to/kyc_document.pdf" \
  -F "input_text=User uploaded KYC doc."

{
  "status": "processing",
  "message": "File accepted. Result will be dispatched to your Webhook."
}

{
  "event": "scan.completed",
  "timestamp": 1712419200,
  "data": {
    "risk_level": "DANGER",
    "reason": "Hidden Javascript Execution Block found inside PDF.",
    "file": "kyc_document.pdf"
  }
}

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

// Important: We need the raw body to verify the signature exactly
app.post('/webhook', express.raw({type: 'application/json'}), (req, res) => {
    const signature = req.headers['aeglis-signature'];
    const secret = process.env.AEGLIS_WEBHOOK_SECRET;
    const expectedSignature = 'v1=' + crypto
        .createHmac('sha256', secret)
        .update(req.body)
        .digest('hex');
    if (crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {
        const payload = JSON.parse(req.body);
        console.log("Valid Webhook received:", payload.data.risk_level);
        res.status(200).send("OK");
    } else {
        res.status(401).send("Invalid signature");
    }
});

npm install aeglis-sdk

const Aeglis = require('aeglis-sdk');

// Initialize the secure singleton instance
// Always use environment variables — never hardcode your key
const aeglis = new Aeglis(process.env.AEGLIS_API_KEY);

aeglis.scan(inputText, endUserId);

async function handleIncomingMessage() {
    try {
        const response = await aeglis.scan(
            "Update your bank KYC immediately at http://secure-alert-update.in",
            "user_id_9982"
        );
        console.log(response);
    } catch (error) {
        console.error(error.message);
    }
}

aeglis.deepScan(filePath, options);

async function handleDocumentUpload() {
    try {
        const response = await aeglis.deepScan(
            './uploads/user_identity_proof.pdf',
            {
                inputText: "User profile onboarding document submission",
                endUserId: "document_reference_ref_5548"
            }
        );
        console.log(response);
    } catch (error) {
        console.error(error.message);
    }
}

{
  "risk_level": "DANGER",
  "reason": "Dormant executable sequence embedded within structural PDF tags discovered during disassembly.",
  "file": "user_identity_proof.pdf",
  "user_id": "document_reference_ref_5548"
}

const express = require('express');
const Aeglis = require('aeglis-sdk');

const app = express();
const aeglis = new Aeglis(process.env.AEGLIS_API_KEY);
const WEBHOOK_SECRET = process.env.AEGLIS_WEBHOOK_SECRET;

app.post(
    '/v1/security-callback',
    express.raw({ type: 'application/json' }), // Raw body — required
    (req, res) => {
        const signatureHeader = req.headers['aeglis-signature'];
        try {
            const event = aeglis.verifyWebhook(req.body, signatureHeader, WEBHOOK_SECRET);
            const entityReferenceId = event.data.user_id;
            if (event.data.risk_level === 'DANGER') {
                console.log(`Threat in ${event.data.file}. Quarantining ref: ${entityReferenceId}`);
            } else if (event.data.risk_level === 'SAFE') {
                console.log(`Ref ${entityReferenceId} verified clean. Committing to storage.`);
            }
            res.status(200).send('OK');
        } catch (error) {
            console.error(`Signature verification failed: ${error.message}`);
            res.status(401).send('Unauthorized');
        }
    }
);

try {
    // Attempting execution with empty target parameters
    await aeglis.scan("");
} catch (error) {
    console.error(error.message);
    // Output: "Aeglis API Error: inputText is required for Quick Scan."
}

pip install aeglis

from aeglis import Aeglis
import os

# Initialize the secure singleton instance
# Always use environment variables — never hardcode your key
client = Aeglis(api_key=os.environ["AEGLIS_API_KEY"])

client.scan(input_text, end_user_id)

try:
    response = client.scan(
        input_text="Verify your account immediately: http://secure-verification-login.in",
        end_user_id="user_db_id_8874"
    )
    print(response)
except Exception as e:
    print(f"Scanning error occurred: {e}")

client.deep_scan(file_path, input_text, end_user_id)

try:
    response = client.deep_scan(
        file_path="./downloads/user_invoice.pdf",
        input_text="User submitted billing proof during KYC verification",
        end_user_id="invoice_ref_doc_9912"  # Returned via webhook
    )
    print(response)
except Exception as e:
    print(f"Deep scan error: {e}")

from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from aeglis import Aeglis, AeglisError
import os

client = Aeglis(api_key=os.environ.get("AEGLIS_API_KEY"))
WEBHOOK_SECRET = os.environ.get("AEGLIS_WEBHOOK_SECRET")

@csrf_exempt
def aeglis_webhook(request):
    raw_payload = request.body  # Capture raw bytes strictly
    signature = request.META.get("HTTP_X_AEGLIS_SIGNATURE") or request.META.get("HTTP_AEGLIS_SIGNATURE")
    
    try:
        event = client.verify_webhook(
            raw_payload=raw_payload,
            signature_header=signature,
            webhook_secret=WEBHOOK_SECRET
        )
        
        # Extract parameters from the nested data wrapper
        event_data = event.get("data", {})
        risk_level = event_data.get("risk_level")
        entity_ref = event_data.get("user_id")
        
        if risk_level == "DANGER":
            print(f"Threat detected. Quarantining ref: {entity_ref}")
        elif risk_level == "SAFE":
            print(f"Ref {entity_ref} verified clean.")
            
        return JsonResponse({"status": "processed"})
        
    except AeglisError as e:
        print(f"Verification failed: {e}")
        return JsonResponse({"error": "Invalid signature"}, status=400)

from aeglis import Aeglis, AeglisError
import os

client = Aeglis(api_key=os.environ["AEGLIS_API_KEY"])

try:
    client.scan(input_text="")  # Empty string validation check
except ValueError as e:
    print(f"Validation error: {e}")
    # Output: input_text is required.
except AeglisError as e:
    print(f"Aeglis server error: {e}")