Webhooks

from vlmrun.client import VLMRun

# Initialize the client
client = VLMRun()

response = client.document.generate(
    file_id="file_abc123",
    domain="document.invoice",
    batch=True,
    callback_url="https://your-domain.com/webhooks/vlmrun"
)


print(f"Request ID: {response.id}")
# Your webhook endpoint will receive the results when processing completes

import { VlmRun } from 'vlmrun';

const client = new VlmRun({
  apiKey: 'your-api-key',
});

const response = await client.document.generate({
  fileId: 'file_abc123',
  domain: 'document.invoice',
  batch: true,
  callbackUrl: 'https://your-domain.com/webhooks/vlmrun'
});

console.log(`Request ID: ${response.id}`);
// Your webhook endpoint will receive the results when processing completes

import os
import json
from vlmrun.common.webhook import verify_webhook

# In your webhook handler, obtain the raw request body (bytes),
# signature header, and webhook secret
raw_body = request.body()  # Must be bytes, not parsed JSON
signature = request.headers.get("X-VLMRun-Signature")
secret = os.environ["VLMRUN_WEBHOOK_SECRET"]

# Verify signature using SDK
if not verify_webhook(raw_body, signature, secret):
    return {"error": "Invalid signature"}, 401

# Parse and process webhook
data = json.loads(raw_body)
print(f"Received webhook for prediction: {data['id']}")

# Handle the completed prediction
if data["status"] == "completed":
    response_data = data["response"]
    # ... your business logic here

return {"status": "success"}

import { verifyWebhook } from 'vlmrun';

// In your webhook handler, obtain the raw request body (Buffer),
// signature header, and webhook secret
const rawBody = req.body;  // Must be Buffer, not parsed JSON
const signature = req.headers['x-vlmrun-signature'];
const secret = process.env.VLMRUN_WEBHOOK_SECRET;

// Verify signature using SDK
if (!verifyWebhook(rawBody, signature, secret)) {
    return res.status(401).json({ error: 'Invalid signature' });
}

// Parse and process webhook
const data = JSON.parse(rawBody.toString('utf8'));
console.log(`Received webhook for prediction: ${data.id}`);

// Handle the completed prediction
if (data.status === 'completed') {
    const responseData = data.response;
    // ... your business logic here
}

res.json({ status: 'success' });

import hmac
import hashlib

def verify_webhook(raw_body: bytes, signature_header: str, secret: str) -> bool:
    if not signature_header or not signature_header.startswith("sha256="):
        return False

    received_sig = signature_header[len("sha256="):]
    expected_sig = hmac.new(
        secret.encode("utf-8"),
        raw_body,
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(received_sig, expected_sig)

# Usage in your webhook handler
raw_body = request.body()
signature = request.headers.get("X-VLMRun-Signature")
secret = os.environ["VLMRUN_WEBHOOK_SECRET"]

if not verify_webhook(raw_body, signature, secret):
    return {"error": "Invalid signature"}, 401

const crypto = require('crypto');

function verifyWebhook(rawBody, signatureHeader, secret) {
    if (!signatureHeader || !signatureHeader.startsWith('sha256=')) {
        return false;
    }

    const receivedSig = signatureHeader.replace('sha256=', '');
    const expectedSig = crypto
        .createHmac('sha256', secret)
        .update(rawBody)
        .digest('hex');

    try {
        return crypto.timingSafeEqual(
            Buffer.from(receivedSig, 'hex'),
            Buffer.from(expectedSig, 'hex')
        );
    } catch (error) {
        return false;
    }
}

// Usage in your webhook handler (with express.raw middleware)
const rawBody = req.body;
const signature = req.headers['x-vlmrun-signature'];
const secret = process.env.VLMRUN_WEBHOOK_SECRET;

if (!verifyWebhook(rawBody, signature, secret)) {
    return res.status(401).json({ error: 'Invalid signature' });
}