#Webhook Integration

go get github.com/transcodely/transcodely-go

pip install transcodely

npm install transcodely

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/transcodely/transcodely-go"
)

func main() {
	client, err := transcodely.New(os.Getenv("TRANSCODELY_API_KEY"))
	if err != nil {
		log.Fatal(err)
	}

	endpoint, err := client.WebhookEndpoints.Create(context.Background(), &transcodely.WebhookEndpointCreateParams{
		AppId:         "app_default000",
		Url:           "https://example.com/webhooks/transcodely",
		EnabledEvents: []string{"job.succeeded", "job.failed", "output.ready"},
		Metadata:      map[string]string{"env": "prod"},
	})
	if err != nil {
		log.Fatal(err)
	}

	// endpoint.GetSecret() is the whsec_… signing secret — returned ONLY here.
	fmt.Println("endpoint:", endpoint.GetId())
	fmt.Println("secret:  ", endpoint.GetSecret())
}

import os

from transcodely import Transcodely

with Transcodely(api_key=os.environ["TRANSCODELY_API_KEY"]) as client:
    endpoint = client.webhook_endpoints.create(
        app_id="app_default000",
        url="https://example.com/webhooks/transcodely",
        enabled_events=["job.succeeded", "job.failed", "output.ready"],
        metadata={"env": "prod"},
    )

    # endpoint.secret is the whsec_… signing secret — returned ONLY here.
    print("endpoint:", endpoint.id)
    print("secret:  ", endpoint.secret)

import { Transcodely } from "transcodely";

const client = new Transcodely({ apiKey: process.env.TRANSCODELY_API_KEY! });

const endpoint = await client.webhookEndpoints.create({
  appId: "app_default000",
  url: "https://example.com/webhooks/transcodely",
  enabledEvents: ["job.succeeded", "job.failed", "output.ready"],
  metadata: { env: "prod" },
});

// endpoint.secret is the whsec_… signing secret — returned ONLY here.
console.log("endpoint:", endpoint.id);
console.log("secret:  ", endpoint.secret);

// Verify and handle incoming webhook deliveries with a net/http receiver.
// Set WEBHOOK_SECRET to the endpoint's whsec_… secret from step 1.
package main

import (
	"io"
	"log"
	"net/http"
	"os"

	"github.com/transcodely/transcodely-go"
)

func main() {
	secret := os.Getenv("WEBHOOK_SECRET")
	if secret == "" {
		log.Fatal("set WEBHOOK_SECRET")
	}

	http.HandleFunc("/webhooks", func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1<<20))
		if err != nil {
			http.Error(w, "read error", http.StatusBadRequest)
			return
		}

		event, err := transcodely.ConstructEvent(body, r.Header.Get(transcodely.SignatureHeader), secret)
		if err != nil {
			// Bad signature, stale timestamp, or malformed body. Reply non-2xx so
			// the platform marks this attempt failed and retries per its curve.
			log.Printf("invalid webhook: %v", err)
			http.Error(w, "invalid signature", http.StatusBadRequest)
			return
		}

		// Acknowledge fast with a 2xx, then do heavy work asynchronously.
		// Deduplicate on event.ID — a retry carries the same evt_ id.
		switch event.Type {
		case transcodely.EventTypeJobSucceeded:
			if job, ok := event.Job(); ok {
				log.Printf("job %s succeeded (status %s)", job.GetId(), job.GetStatus())
			}
		case transcodely.EventTypeOutputReady:
			if out, ok := event.JobOutput(); ok {
				log.Printf("output %s ready at %s", out.GetId(), out.GetOutputUrl())
			}
		default:
			log.Printf("unhandled event %s (%s)", event.Type, event.ID)
		}

		w.WriteHeader(http.StatusOK)
	})

	log.Fatal(http.ListenAndServe(":8080", nil))
}

"""Verify a signed webhook delivery and dispatch on the event type.

What matters is passing the *raw* request body (bytes, exactly as received) and the
Transcodely-Signature header to construct_event. This dependency-free WSGI handler runs
anywhere; swap in your Flask/FastAPI/Django request objects as needed.
"""

import os

from transcodely import (
    Event,
    WebhookSignatureError,
    WebhookTimestampError,
    construct_event,
)

WEBHOOK_SECRET = os.environ["WEBHOOK_SECRET"]


def handle_event(event: Event) -> None:
    if event.type == "job.succeeded":
        print(f"job {event.data.id} finished")
    elif event.type == "job.failed":
        print(f"job {event.data.id} failed")
    elif event.type == "output.ready":
        print(f"output {event.data.id} ready: {event.data.output_url}")
    else:
        # Forward-compatible: unknown future types still verify.
        print(f"unhandled event {event.type}")


def webhook_app(environ, start_response):
    length = int(environ.get("CONTENT_LENGTH") or 0)
    raw_body = environ["wsgi.input"].read(length)  # raw bytes — never re-serialize
    sig_header = environ.get("HTTP_TRANSCODELY_SIGNATURE", "")

    try:
        event = construct_event(raw_body, sig_header, WEBHOOK_SECRET)
    except (WebhookSignatureError, WebhookTimestampError) as err:
        start_response("400 Bad Request", [("Content-Type", "text/plain")])
        return [f"signature check failed: {err}".encode()]

    handle_event(event)

    # Ack quickly (2xx) so the platform marks the delivery succeeded.
    start_response("200 OK", [("Content-Type", "text/plain")])
    return [b"ok"]


if __name__ == "__main__":
    from wsgiref.simple_server import make_server

    make_server("", 8000, webhook_app).serve_forever()

import express from "express";

import {
  Transcodely,
  WebhookPayloadError,
  WebhookSignatureError,
  WebhookTimestampError,
} from "transcodely";

const client = new Transcodely({ apiKey: process.env.TRANSCODELY_API_KEY ?? "" });
const secret = process.env.WEBHOOK_SECRET ?? "";

const app = express();

app.post(
  "/webhooks/transcodely",
  // Use raw() — the signature is computed over the literal request body,
  // so JSON.parse'ing first would change the bytes and break verification.
  express.raw({ type: "application/json" }),
  (req, res) => {
    const sigHeader = req.header("transcodely-signature");
    if (!sigHeader) {
      res.status(400).send("missing transcodely-signature header");
      return;
    }

    try {
      const event = client.webhooks.constructEvent(req.body, sigHeader, secret);

      switch (event.type) {
        case "job.succeeded":
          console.log(`[${event.id}] job ${event.data.id} finished`);
          break;
        case "job.failed":
          console.warn(`[${event.id}] job ${event.data.id} failed`);
          break;
        case "output.ready":
          console.log(`[${event.id}] output ${event.data.id} ready: ${event.data.outputUrl}`);
          break;
        default:
          console.log(`[${event.id}] unhandled type ${event.type}`);
      }

      res.sendStatus(200);
    } catch (err) {
      if (err instanceof WebhookSignatureError) {
        res.status(400).send("invalid signature");
        return;
      }
      if (err instanceof WebhookTimestampError) {
        res.status(400).send("signature timestamp out of tolerance");
        return;
      }
      if (err instanceof WebhookPayloadError) {
        res.status(400).send("invalid envelope shape");
        return;
      }
      throw err;
    }
  },
);

app.listen(4242, () => console.log("listening on :4242"));

if (await alreadyProcessed(event.id)) {
  res.sendStatus(200); // ack, but don't act twice
  return;
}
await markProcessed(event.id);
// … enqueue work …

if already_processed(event.id):
    start_response("200 OK", [("Content-Type", "text/plain")])
    return [b"ok"]  # ack, but don't act twice
mark_processed(event.id)
# … enqueue work …

if alreadyProcessed(event.ID) {
	w.WriteHeader(http.StatusOK) // ack, but don't act twice
	return
}
markProcessed(event.ID)
// … enqueue work …

delivery, err := client.WebhookEndpoints.SendTest(context.Background(), "whe_a1b2c3d4e5f6", transcodely.EventTypeJobSucceeded)
if err != nil {
	log.Fatal(err)
}
log.Printf("test delivery %s → status %s", delivery.GetId(), delivery.GetStatus())

delivery = client.webhook_endpoints.send_test("whe_a1b2c3d4e5f6", "job.succeeded")
print("test delivery", delivery.id, "→", delivery.status)

const delivery = await client.webhookEndpoints.sendTest("whe_a1b2c3d4e5f6", "job.succeeded");
console.log("test delivery", delivery.id, "→", delivery.status);

health, err := client.WebhookEndpoints.GetHealth(context.Background(), "whe_a1b2c3d4e5f6", transcodely.HealthWindow24h)
if err != nil {
	log.Fatal(err)
}
log.Printf("24h success rate: %.1f%% (%d ok / %d failed)",
	health.GetSuccessRate()*100, health.GetSucceeded(), health.GetFailed())

health = client.webhook_endpoints.get_health("whe_a1b2c3d4e5f6", "24h")
print(f"24h success rate: {health.success_rate * 100:.1f}% "
      f"({health.succeeded} ok / {health.failed} failed)")

const health = await client.webhookEndpoints.getHealth("whe_a1b2c3d4e5f6", "24h");
console.log(`24h success rate: ${(health.successRate * 100).toFixed(1)}% ` +
  `(${health.succeeded} ok / ${health.failed} failed)`);

event, err := transcodely.ConstructEventWithSecrets(
	body, r.Header.Get(transcodely.SignatureHeader),
	[]string{newSecret, previousSecret})

event = construct_event(raw_body, sig_header, [new_secret, previous_secret])

const event = client.webhooks.constructEvent(req.body, sigHeader, [newSecret, previousSecret]);