Video API Webhooks

        # app/controllers/webhooks_controller.rb
        require 'openssl'
        require 'base64'
        require 'json'

        class WebhooksController < ApplicationController
          # Skip CSRF protection for webhooks
          skip_before_action :verify_authenticity_token

          def receive
            begin
              # Parse the request body
              request_body = request.body.read
              data = JSON.parse(request_body)

              payload = data['data']
              received_signature = data['signature']

              if payload.nil? || received_signature.nil?
                return render json: { status: 'error', message: 'Missing data or signature' }, status: 400
              end

              # For testing, use a hardcoded token
              test_token = ''

              # Convert payload to JSON string in the same way as the sender
              # Sort keys to ensure consistent ordering
              payload_json = JSON.generate(payload.sort.to_h)

              # Compute the expected signature
              digest = OpenSSL::HMAC.digest('SHA256', test_token, payload_json)
              expected_signature = Base64.strict_encode64(digest)

              # Verify signatures match using constant-time comparison to prevent timing attacks
              if !ActiveSupport::SecurityUtils.secure_compare(expected_signature, received_signature)
                return render json: { status: 'error', message: 'Invalid signature' }, status: 403
              end

              # Process the webhook data
              request_id = payload['uuid']
              status = payload['status']
              timestamp = payload['timestamp']

              # Log all received data for testing purposes
              Rails.logger.info("Webhook received with payload: #{payload}")
              Rails.logger.info("Request ID: #{request_id}")
              Rails.logger.info("Status: #{status}")
              Rails.logger.info("Timestamp: #{timestamp}")

              # Return all data for verification purposes
              render json: {
                status: 'success',
                message: "Webhook processed for request #{request_id}",
                received_data: payload
              }

            rescue JSON::ParserError
              render json: { status: 'error', message: 'Invalid JSON' }, status: 400
            rescue StandardError => e
              Rails.logger.error("Webhook error: #{e.message}\n#{e.backtrace.join("\n")}")
              render json: { status: 'error', message: "Unexpected error: #{e.message}" }, status: 500
            end
          end
        end

        # config/routes.rb
        Rails.application.routes.draw do
          post '/webhook', to: 'webhooks#receive'
        end
    

        const express = require('express');
        const crypto = require('crypto');
        const bodyParser = require('body-parser');

        const app = express();
        app.use(bodyParser.json());

        app.post('/webhook', (req, res) => {
            try {
                const data = req.body;
                const payload = data.data;
                const receivedSignature = data.signature;

                if (!payload || !receivedSignature) {
                    return res.status(400).json({
                        status: "error",
                        message: "Missing data or signature"
                    });
                }

                // For testing, use a hardcoded token
                const testToken = "";

                // Convert payload to JSON string in the same way as the sender
                const payloadJson = JSON.stringify(payload, Object.keys(payload).sort());

                // Compute the expected signature
                const hmac = crypto.createHmac('sha256', testToken);
                hmac.update(payloadJson);
                const expectedSignature = hmac.digest('base64');

                // Verify signatures match using constant-time comparison to prevent timing attacks
                const signaturesMatch = crypto.timingSafeEqual(
                    Buffer.from(expectedSignature),
                    Buffer.from(receivedSignature)
                );

                if (!signaturesMatch) {
                    return res.status(403).json({
                        status: "error",
                        message: "Invalid signature"
                    });
                }

                // Process the webhook data
                const requestId = payload.uuid;
                const status = payload.status;
                const timestamp = payload.timestamp;

                // Log all received data for testing purposes
                console.log("Webhook received with payload:", payload);
                console.log(`Request ID: ${requestId}`);
                console.log(`Status: ${status}`);
                console.log(`Timestamp: ${timestamp}`);

                // Return all data for verification purposes
                return res.status(200).json({
                    status: "success",
                    message: `Webhook processed for request ${requestId}`,
                    received_data: payload
                });

            } catch (error) {
                console.error('Webhook processing error:', error);
                return res.status(500).json({
                    status: "error",
                    message: `Unexpected error: ${error.message}`
                });
            }
        });

        const PORT = process.env.PORT || 3000;
        app.listen(PORT, () => {
            console.log(`Server listening on port ${PORT}`);
        });
    

        from fastapi import FastAPI, Request, HTTPException
        from fastapi.responses import JSONResponse
        from pydantic import BaseModel
        from typing import Dict, Any, Optional
        import hmac
        import hashlib
        import base64
        import json
        import logging

        app = FastAPI()

        # Configure logging
        logging.basicConfig(level=logging.INFO)
        logger = logging.getLogger(__name__)

        class WebhookPayload(BaseModel):
            data: Dict[str, Any]
            signature: str

        @app.post("/webhook")
        async def webhook_receiver(request: Request):
            try:
                # Get the raw request body
                body = await request.body()

                # Parse the JSON manually (not using the Pydantic model directly for raw access)
                data = json.loads(body)
                payload = data.get('data')
                received_signature = data.get('signature')

                if not payload or not received_signature:
                    raise HTTPException(
                        status_code=400,
                        detail={"status": "error", "message": "Missing data or signature"}
                    )

                # For testing, use a hardcoded token
                test_token = ""

                # Convert payload to JSON string in the same way as the sender
                payload_json = json.dumps(payload, sort_keys=True)

                # Compute the expected signature
                expected_signature = hmac.new(
                    key=test_token.encode('utf-8'),
                    msg=payload_json.encode('utf-8'),
                    digestmod=hashlib.sha256
                ).digest()

                # Base64 encode for comparison
                expected_signature_b64 = base64.b64encode(expected_signature).decode('utf-8')

                # Verify signatures match using constant-time comparison to prevent timing attacks
                if not hmac.compare_digest(expected_signature_b64, received_signature):
                    raise HTTPException(
                        status_code=403,
                        detail={"status": "error", "message": "Invalid signature"}
                    )

                # Process the webhook data
                request_id = payload.get('uuid')
                status = payload.get('status')
                timestamp = payload.get('timestamp')

                # Log all received data for testing purposes
                logger.info(f"Webhook received with payload: {payload}")
                logger.info(f"Request ID: {request_id}")
                logger.info(f"Status: {status}")
                logger.info(f"Timestamp: {timestamp}")

                # Return all data for verification purposes
                return {
                    "status": "success",
                    "message": f"Webhook processed for request {request_id}",
                    "received_data": payload
                }

            except json.JSONDecodeError:
                raise HTTPException(
                    status_code=400,
                    detail={"status": "error", "message": "Invalid JSON"}
                )
            except Exception as e:
                import traceback
                logger.error(f"Error processing webhook: {str(e)}\n{traceback.format_exc()}")
                raise HTTPException(
                    status_code=500,
                    detail={"status": "error", "message": f"Unexpected error: {str(e)}"}
                )

        if __name__ == "__main__":
            import uvicorn
            uvicorn.run(app, host="0.0.0.0", port=8000)
    

         'error',
                    'message' => 'Invalid JSON: ' . json_last_error_msg()
                ]);
                exit;
            }

            // Extract payload and signature
            $payload = $data['data'] ?? null;
            $receivedSignature = $data['signature'] ?? null;

            // Validate required fields
            if (empty($payload) || empty($receivedSignature)) {
                http_response_code(400);
                echo json_encode([
                    'status' => 'error',
                    'message' => 'Missing data or signature'
                ]);
                exit;
            }

            // For testing, use a hardcoded token
            $testToken = '';

            // Convert payload to JSON string in the same way as the sender
            // Make sure to sort the keys for consistent ordering
            ksort($payload);
            $payloadJson = json_encode($payload);

            // Compute the expected signature
            $expectedSignature = base64_encode(
                hash_hmac('sha256', $payloadJson, $testToken, true)
            );

            // Verify signatures match using constant-time comparison to prevent timing attacks
            if (!hash_equals($expectedSignature, $receivedSignature)) {
                http_response_code(403);
                echo json_encode([
                    'status' => 'error',
                    'message' => 'Invalid signature'
                ]);
                exit;
            }

            // Process the webhook data
            $requestId = $payload['uuid'] ?? 'unknown';
            $status = $payload['status'] ?? 'unknown';
            $timestamp = $payload['timestamp'] ?? 'unknown';

            // Log all received data for testing purposes
            error_log("Webhook received with payload: " . print_r($payload, true));
            error_log("Request ID: $requestId");
            error_log("Status: $status");
            error_log("Timestamp: $timestamp");

            // Return all data for verification purposes
            http_response_code(200);
            echo json_encode([
                'status' => 'success',
                'message' => "Webhook processed for request $requestId",
                'received_data' => $payload
            ]);

        } catch (Exception $e) {
            // Log the error
            error_log("Webhook error: " . $e->getMessage() . "\n" . $e->getTraceAsString());

            // Return error response
            http_response_code(500);
            echo json_encode([
                'status' => 'error',
                'message' => 'Unexpected error: ' . $e->getMessage()
            ]);
        }
        ?>