curl -X POST https://api.pdfapi.dev/v1/webhooks/config \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.com/webhooks/pdfapi",
    "events": ["pdf.generated", "pdf.failed"],
    "secret": "your-webhook-secret-key"
  }'

const response = await fetch('https://api.pdfapi.dev/v1/webhooks/config', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.PDFAPI_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    url: 'https://your-app.com/webhooks/pdfapi',
    events: ['pdf.generated', 'pdf.failed'],
    secret: 'your-webhook-secret-key'
  }),
});

const { data } = await response.json();
console.log('Webhook configured:', data.id);

import requests
import os

response = requests.post(
    'https://api.pdfapi.dev/v1/webhooks/config',
    headers={
        'Authorization': f'Bearer {os.environ["PDFAPI_KEY"]}',
        'Content-Type': 'application/json',
    },
    json={
        'url': 'https://your-app.com/webhooks/pdfapi',
        'events': ['pdf.generated', 'pdf.failed'],
        'secret': 'your-webhook-secret-key'
    }
)

config = response.json()['data']
print(f"Webhook ID: {config['id']}")
print(f"URL: {config['url']}")

curl https://api.pdfapi.dev/v1/webhooks/config \
  -H "Authorization: Bearer sk_live_xxx"

const response = await fetch('https://api.pdfapi.dev/v1/webhooks/config', {
  headers: {
    'Authorization': `Bearer ${process.env.PDFAPI_KEY}`,
  },
});

const { data } = await response.json();
if (data) {
  console.log('Webhook URL:', data.url);
  console.log('Events:', data.events);
} else {
  console.log('No webhook configured');
}

import requests
import os

response = requests.get(
    'https://api.pdfapi.dev/v1/webhooks/config',
    headers={'Authorization': f'Bearer {os.environ["PDFAPI_KEY"]}'}
)

config = response.json().get('data')
if config:
    print(f"Webhook URL: {config['url']}")
    print(f"Active: {config['active']}")

curl -X DELETE https://api.pdfapi.dev/v1/webhooks/config \
  -H "Authorization: Bearer sk_live_xxx"

const response = await fetch('https://api.pdfapi.dev/v1/webhooks/config', {
  method: 'DELETE',
  headers: {
    'Authorization': `Bearer ${process.env.PDFAPI_KEY}`,
  },
});

if (response.status === 204) {
  console.log('Webhook configuration deleted');
}

import requests
import os

response = requests.delete(
    'https://api.pdfapi.dev/v1/webhooks/config',
    headers={'Authorization': f'Bearer {os.environ["PDFAPI_KEY"]}'}
)

if response.status_code == 204:
    print('Webhook configuration deleted')

import crypto from 'crypto';

function verifyWebhookSignature(payload, signature, timestamp, secret) {
  const signedPayload = `${timestamp}.${JSON.stringify(payload)}`;
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(signedPayload)
    .digest('hex');

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

// Express.js example
app.post('/webhooks/pdfapi', express.json(), (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  const timestamp = req.headers['x-webhook-timestamp'];

  if (!verifyWebhookSignature(req.body, signature, timestamp, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }

  // Process the webhook
  const { type, data } = req.body;
  console.log(`Received ${type} event:`, data);

  res.status(200).send('OK');
});

import hmac
import hashlib
import json
from flask import Flask, request, abort

app = Flask(__name__)

def verify_webhook_signature(payload, signature, timestamp, secret):
    signed_payload = f"{timestamp}.{json.dumps(payload, separators=(',', ':'))}"
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        signed_payload.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(signature, expected_signature)

@app.route('/webhooks/pdfapi', methods=['POST'])
def webhook_handler():
    signature = request.headers.get('X-Webhook-Signature')
    timestamp = request.headers.get('X-Webhook-Timestamp')

    if not verify_webhook_signature(
        request.json, signature, timestamp, os.environ['WEBHOOK_SECRET']
    ):
        abort(401)

    event_type = request.json['type']
    event_data = request.json['data']

    print(f"Received {event_type} event:", event_data)

    return 'OK', 200

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "net/http"
)

func verifyWebhookSignature(payload []byte, signature, timestamp, secret string) bool {
    signedPayload := fmt.Sprintf("%s.%s", timestamp, string(payload))
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(signedPayload))
    expectedSignature := hex.EncodeToString(mac.Sum(nil))

    return hmac.Equal([]byte(signature), []byte(expectedSignature))
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    signature := r.Header.Get("X-Webhook-Signature")
    timestamp := r.Header.Get("X-Webhook-Timestamp")

    var payload map[string]interface{}
    json.NewDecoder(r.Body).Decode(&payload)

    payloadBytes, _ := json.Marshal(payload)

    if !verifyWebhookSignature(payloadBytes, signature, timestamp, os.Getenv("WEBHOOK_SECRET")) {
        http.Error(w, "Invalid signature", http.StatusUnauthorized)
        return
    }

    fmt.Printf("Received %s event\n", payload["type"])
    w.WriteHeader(http.StatusOK)
}