Webhooks

POST /api/webhook/fluxpool HTTP/1.1
Host: yourserver.com
Content-Type: application/json
X-Fluxpool-Signature: sha256=a1b2c3d4e5f6...
X-Fluxpool-Event: generation.completed
X-Fluxpool-Delivery: dlv_unique_id
User-Agent: Fluxpool-Webhook/1.0

{
  "id": "gen_abc123",
  "object": "generation",
  "event": "generation.completed",
  "created": 1719500000,
  "model": "flux-1.1-pro",
  "status": "completed",
  "type": "image",
  "prompt": "A dragon on a neon-lit Tokyo rooftop, 8K",
  "output": {
    "url": "https://cdn.fluxpool.ai/generations/gen_abc123.png",
    "width": 1024,
    "height": 1024,
    "format": "png",
    "expires_at": 1719586400
  },
  "usage": {
    "credits_used": 3,
    "credits_remaining": 147
  },
  "duration_ms": 3200,
  "metadata": {}
}

{
  "id": "gen_xyz789",
  "object": "generation",
  "event": "generation.completed",
  "created": 1719500000,
  "model": "wan-video-2.1",
  "status": "completed",
  "type": "video",
  "prompt": "A koi fish transforming into a phoenix, slow motion",
  "output": {
    "url": "https://cdn.fluxpool.ai/generations/gen_xyz789.mp4",
    "width": 1280,
    "height": 720,
    "format": "mp4",
    "duration_seconds": 4.0,
    "fps": 24,
    "expires_at": 1719586400
  },
  "usage": {
    "credits_used": 15,
    "credits_remaining": 132
  },
  "duration_ms": 47200,
  "metadata": {}
}

{
  "id": "gen_err456",
  "object": "generation",
  "event": "generation.failed",
  "created": 1719500000,
  "model": "kling-v2",
  "status": "failed",
  "type": "video",
  "prompt": "...",
  "error": {
    "code": "model_overloaded",
    "message": "Model temporarily unavailable. Try again or use a different model."
  },
  "usage": {
    "credits_used": 0,
    "credits_remaining": 147
  },
  "metadata": {}
}

import crypto from "crypto";

function verifyWebhook(req, secret) {
  const payload = JSON.stringify(req.body);
  const signature = req.headers["x-fluxpool-signature"];

  const expected = "sha256=" +
    crypto.createHmac("sha256", secret)
      .update(payload)
      .digest("hex");

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

import hmac
import hashlib

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

# Terminal 1: Start your local server
node server.js  # listening on port 3000

# Terminal 2: Start ngrok
ngrok http 3000
# → https://abc123.ngrok.io

# Use the ngrok URL as your webhook_url
# webhook_url: "https://abc123.ngrok.io/api/webhook/fluxpool"

import express from "express";
import crypto from "crypto";

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

const WEBHOOK_SECRET = process.env.FLUXPOOL_WEBHOOK_SECRET;

app.post("/api/webhook/fluxpool", (req, res) => {
  // 1. Verify signature
  const signature = req.headers["x-fluxpool-signature"];
  const expected = "sha256=" +
    crypto.createHmac("sha256", WEBHOOK_SECRET)
      .update(JSON.stringify(req.body))
      .digest("hex");

  if (!crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  )) {
    return res.status(401).send("Invalid signature");
  }

  // 2. Return 200 immediately
  res.status(200).send("OK");

  // 3. Process async
  const { id, event, type, output, error } = req.body;

  if (event === "generation.completed") {
    console.log(`✅ ${type} ready: ${output.url}`);
    // Download the asset, save to your storage, notify user, etc.
  }

  if (event === "generation.failed") {
    console.error(`❌ Generation ${id} failed: ${error.message}`);
    // Handle failure: retry, notify user, log, etc.
  }
});

app.listen(3000, () => console.log("Webhook server running on :3000"));

from fastapi import FastAPI, Request, HTTPException
import hmac
import hashlib
import os

app = FastAPI()

WEBHOOK_SECRET = os.environ["FLUXPOOL_WEBHOOK_SECRET"]

@app.post("/api/webhook/fluxpool")
async def handle_webhook(request: Request):
    # 1. Read raw body for signature verification
    body = await request.body()
    signature = request.headers.get("x-fluxpool-signature", "")

    expected = "sha256=" + hmac.new(
        WEBHOOK_SECRET.encode(),
        body,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected, signature):
        raise HTTPException(status_code=401, detail="Invalid signature")

    # 2. Parse payload
    payload = await request.json()

    if payload["event"] == "generation.completed":
        print(f"✅ {payload['type']} ready: {payload['output']['url']}")
        # Download, store, notify...

    if payload["event"] == "generation.failed":
        print(f"❌ Failed: {payload['error']['message']}")
        # Handle failure...

    return {"status": "ok"}