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

// Parse JSON request bodies
app.use(express.json());

app.post('/webhooks/notchpay', (req, res) => {
  // Return a 200 response immediately
  res.status(200).send('Webhook received');
  
  // Process the webhook asynchronously
  const event = req.body;
  processWebhook(event);
});

function processWebhook(event) {
  const eventType = event.type;
  const eventData = event.data;
  
  switch (eventType) {
    case 'payment.complete':
      // Handle completed payment
      console.log(`Payment ${eventData.id} completed`);
      break;
    case 'payment.failed':
      // Handle failed payment
      console.log(`Payment ${eventData.id} failed`);
      break;
    // Handle other event types
  }
}

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

<?php
// Get the request body
$input = file_get_contents('php://input');
$event = json_decode($input, true);

// Return a 200 response immediately
http_response_code(200);
header('Content-Type: application/json');
echo json_encode(['status' => 'received']);

// Process the webhook asynchronously
if (function_exists('fastcgi_finish_request')) {
    fastcgi_finish_request();
}

// Process the webhook
$eventType = $event['type'];
$eventData = $event['data'];

switch ($eventType) {
    case 'payment.complete':
        // Handle completed payment
        error_log("Payment {$eventData['id']} completed");
        break;
    case 'payment.failed':
        // Handle failed payment
        error_log("Payment {$eventData['id']} failed");
        break;
    // Handle other event types
}

from flask import Flask, request, jsonify
import threading

app = Flask(__name__)

@app.route('/webhooks/notchpay', methods=['POST'])
def webhook():
    # Return a 200 response immediately
    event = request.json
    
    # Process the webhook asynchronously
    threading.Thread(target=process_webhook, args=(event,)).start()
    
    return jsonify({'status': 'received'}), 200

def process_webhook(event):
    event_type = event['type']
    event_data = event['data']
    
    if event_type == 'payment.complete':
        # Handle completed payment
        print(f"Payment {event_data['id']} completed")
    elif event_type == 'payment.failed':
        # Handle failed payment
        print(f"Payment {event_data['id']} failed")
    # Handle other event types

if __name__ == '__main__':
    app.run(port=3000)

curl https://api.notchpay.co/webhooks \
  -H "Authorization: YOUR_PUBLIC_KEY" \
  -H "X-Grant: YOUR_PRIVATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/webhooks/notchpay",
    "events": ["payment.complete", "payment.failed"],
    "description": "Payment notifications for my e-commerce site"
  }'

const crypto = require('crypto');

function verifySignature(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  const calculatedSignature = hmac.update(payload).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(calculatedSignature, 'hex'),
    Buffer.from(signature, 'hex')
  );
}

app.post('/webhooks/notchpay', express.raw({type: 'application/json'}), (req, res) => {
  const signature = req.headers['x-notch-signature'];
  const payload = req.body.toString();
  
  if (!verifySignature(payload, signature, 'your_webhook_secret')) {
    return res.status(400).send('Invalid signature');
  }
  
  const event = JSON.parse(payload);
  // Process the event
  
  res.status(200).send('Webhook received');
});

<?php
function verifySignature($payload, $signature, $secret) {
  $calculatedSignature = hash_hmac('sha256', $payload, $secret);
  return hash_equals($calculatedSignature, $signature);
}

$payload = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_NOTCH_SIGNATURE'];

if (!verifySignature($payload, $signature, 'your_webhook_secret')) {
  http_response_code(400);
  echo 'Invalid signature';
  exit;
}

$event = json_decode($payload, true);
// Process the event

import hmac
import hashlib

def verify_signature(payload, signature, secret):
    calculated_signature = hmac.new(
        secret.encode('utf-8'),
        payload.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(calculated_signature, signature)

@app.route('/webhooks/notchpay', methods=['POST'])
def webhook():
    payload = request.data.decode('utf-8')
    signature = request.headers.get('X-Notch-Signature')
    
    if not verify_signature(payload, signature, 'your_webhook_secret'):
        return 'Invalid signature', 400
    
    event = json.loads(payload)
    # Process the event
    
    return jsonify({'status': 'received'}), 200