Webhooks

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

app.post('/webhooks/smartbills', express.json(), (req, res) => {
  const event = req.body;
  
  // Verify webhook signature
  const signature = req.headers['x-smartbills-signature'];
  if (!verifySignature(event, signature)) {
    return res.status(401).send('Invalid signature');
  }
  
  // Process the event
  console.log('Received event:', event.type);
  
  switch (event.type) {
    case 'expense.created':
      handleExpenseCreated(event.data);
      break;
    case 'report.approved':
      handleReportApproved(event.data);
      break;
    default:
      console.log(`Unhandled event type: ${event.type}`);
  }
  
  // Return 200 OK
  res.status(200).send('Webhook received');
});

app.listen(3000);

from flask import Flask, request, jsonify
import hmac
import hashlib

app = Flask(__name__)

@app.route('/webhooks/smartbills', methods=['POST'])
def handle_webhook():
    event = request.json
    signature = request.headers.get('X-Smartbills-Signature')
    
    # Verify signature
    if not verify_signature(event, signature):
        return jsonify({'error': 'Invalid signature'}), 401
    
    # Process event
    event_type = event['type']
    
    if event_type == 'expense.created':
        handle_expense_created(event['data'])
    elif event_type == 'report.approved':
        handle_report_approved(event['data'])
    
    return jsonify({'status': 'success'}), 200

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

<?php
// webhooks.php

$payload = file_get_contents('php://input');
$event = json_decode($payload, true);
$signature = $_SERVER['HTTP_X_SMARTBILLS_SIGNATURE'];

// Verify signature
if (!verifySignature($payload, $signature)) {
    http_response_code(401);
    die('Invalid signature');
}

// Process event
switch ($event['type']) {
    case 'expense.created':
        handleExpenseCreated($event['data']);
        break;
    case 'report.approved':
        handleReportApproved($event['data']);
        break;
}

http_response_code(200);
echo json_encode(['status' => 'success']);
?>

require 'sinatra'
require 'json'

post '/webhooks/smartbills' do
  payload = request.body.read
  event = JSON.parse(payload)
  signature = request.env['HTTP_X_SMARTBILLS_SIGNATURE']
  
  # Verify signature
  unless verify_signature(payload, signature)
    status 401
    return { error: 'Invalid signature' }.to_json
  end
  
  # Process event
  case event['type']
  when 'expense.created'
    handle_expense_created(event['data'])
  when 'report.approved'
    handle_report_approved(event['data'])
  end
  
  status 200
  { status: 'success' }.to_json
end

curl --request POST \
  --url https://api.smartbills.io/v1/webhooks \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "url": "https://your-domain.com/webhooks/smartbills",
    "events": ["expense.created", "report.approved"],
    "description": "Production webhook endpoint"
  }'

const response = await fetch('https://api.smartbills.io/v1/webhooks', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    url: 'https://your-domain.com/webhooks/smartbills',
    events: ['expense.created', 'report.approved'],
    description: 'Production webhook endpoint'
  })
});

const webhook = await response.json();
console.log('Webhook ID:', webhook.id);

import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
}

data = {
    'url': 'https://your-domain.com/webhooks/smartbills',
    'events': ['expense.created', 'report.approved'],
    'description': 'Production webhook endpoint'
}

response = requests.post(
    'https://api.smartbills.io/v1/webhooks',
    headers=headers,
    json=data
)

webhook = response.json()
print(f"Webhook ID: {webhook['id']}")

const crypto = require('crypto');

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

// Usage
const isValid = verifySignature(
  req.body,
  req.headers['x-smartbills-signature'],
  process.env.WEBHOOK_SECRET
);

import hmac
import hashlib

def verify_signature(payload, signature, secret):
    computed = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(computed, signature)

# Usage
is_valid = verify_signature(
    request.data.decode(),
    request.headers.get('X-Smartbills-Signature'),
    os.environ['WEBHOOK_SECRET']
)

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

// Usage
$isValid = verifySignature(
    file_get_contents('php://input'),
    $_SERVER['HTTP_X_SMARTBILLS_SIGNATURE'],
    getenv('WEBHOOK_SECRET')
);
?>

require 'openssl'

def verify_signature(payload, signature, secret)
  computed = OpenSSL::HMAC.hexdigest('SHA256', secret, payload)
  Rack::Utils.secure_compare(computed, signature)
end

# Usage
is_valid = verify_signature(
  request.body.read,
  request.env['HTTP_X_SMARTBILLS_SIGNATURE'],
  ENV['WEBHOOK_SECRET']
)