Webhooks

curl -X POST "https://videoconduit.com/v1/webhooks" \
  -H "Authorization: Bearer vc_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://yourapp.com/webhooks/videoconduit",
    "events": ["job.completed", "job.failed"]
  }'

import requests

response = requests.post(
    "https://videoconduit.com/v1/webhooks",
    headers={"Authorization": "Bearer vc_your_api_key"},
    json={
        "url": "https://yourapp.com/webhooks/videoconduit",
        "events": ["job.completed", "job.failed"],
    },
)
webhook = response.json()
print(webhook["id"], webhook["secret"])

const response = await fetch("https://videoconduit.com/v1/webhooks", {
  method: "POST",
  headers: {
    "Authorization": "Bearer vc_your_api_key",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    url: "https://yourapp.com/webhooks/videoconduit",
    events: ["job.completed", "job.failed"],
  }),
});
const webhook = await response.json();
console.log(webhook.id, webhook.secret);

$client = new GuzzleHttp\Client();
$response = $client->post("https://videoconduit.com/v1/webhooks", [
    "headers" => ["Authorization" => "Bearer vc_your_api_key"],
    "json" => [
        "url" => "https://yourapp.com/webhooks/videoconduit",
        "events" => ["job.completed", "job.failed"],
    ],
]);
$webhook = json_decode($response->getBody(), true);
echo $webhook["id"] . " " . $webhook["secret"];

body := strings.NewReader(`{
  "url": "https://yourapp.com/webhooks/videoconduit",
  "events": ["job.completed", "job.failed"]
}`)
req, _ := http.NewRequest("POST", "https://videoconduit.com/v1/webhooks", body)
req.Header.Set("Authorization", "Bearer vc_your_api_key")
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var webhook map[string]interface{}
json.NewDecoder(resp.Body).Decode(&webhook)

require "net/http"
require "json"

uri = URI("https://videoconduit.com/v1/webhooks")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer vc_your_api_key"
req["Content-Type"] = "application/json"
req.body = {
  url: "https://yourapp.com/webhooks/videoconduit",
  events: ["job.completed", "job.failed"],
}.to_json
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
webhook = JSON.parse(res.body)
puts webhook["id"], webhook["secret"]

import hmac
import hashlib


def verify_webhook(payload: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(
        secret.encode(),
        payload,
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, signature)


# In your webhook handler:
signature = request.headers.get("X-VideoConduit-Signature")
if not verify_webhook(request.body, signature, WEBHOOK_SECRET):
    return HttpResponse(status=401)  # Reject

const crypto = require("crypto");

function verifyWebhook(payload, signature, secret) {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(payload)
    .digest("hex");
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature)
  );
}

// In your webhook handler:
const signature = req.headers["x-videoconduit-signature"];
if (!verifyWebhook(req.body, signature, WEBHOOK_SECRET)) {
  return res.status(401).send();
}

function verifyWebhook(string $payload, string $signature, string $secret): bool {
    $expected = hash_hmac("sha256", $payload, $secret);
    return hash_equals($expected, $signature);
}

// In your webhook handler:
$payload = file_get_contents("php://input");
$signature = $_SERVER["HTTP_X_VIDEOCONDUIT_SIGNATURE"] ?? "";
if (!verifyWebhook($payload, $signature, $webhookSecret)) {
    http_response_code(401);
    exit;
}

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
)

func verifyWebhook(payload []byte, signature, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(payload)
    expected := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(expected), []byte(signature))
}

// In your webhook handler:
// signature := r.Header.Get("X-VideoConduit-Signature")
// if !verifyWebhook(body, signature, webhookSecret) {
//     w.WriteHeader(http.StatusUnauthorized)
// }

require "openssl"

def verify_webhook(payload, signature, secret)
  expected = OpenSSL::HMAC.hexdigest("SHA256", secret, payload)
  Rack::Utils.secure_compare(expected, signature)
end

# In your webhook handler:
signature = request.env["HTTP_X_VIDEOCONDUIT_SIGNATURE"]
unless verify_webhook(request.body.read, signature, WEBHOOK_SECRET)
  halt 401
end