Drei Wege, ein Prinzip
Automatisierungsplattformen setzen technisch auf demselben Fundament auf, das auch eigene Skripte nutzen: Webhooks für „pixx.io meldet sich, wenn etwas passiert" und die REST-API für „Ergebnisse zurückschreiben". Der Unterschied liegt darin, wie viel davon bereits vorgefertigt ist:
- Make bietet eine offizielle pixx.io-App mit fertigen Modulen — kein Webhook-Setup von Hand nötig.
- Zapier und n8n haben (aktuell) keine eigene pixx.io-App, lassen sich aber genauso zuverlässig über den generischen Webhook-Trigger anbinden.
- Dasselbe Prinzip funktioniert mit praktisch jeder Plattform, die einen Webhook-Trigger und ein HTTP-Modul mitbringt — etwa Power Automate oder Pabbly Connect.
Plattformen im Vergleich
Make
Eigene pixx.io-App im Make-Store mit vorgefertigten Triggern und Actions. Schnellster Einstieg, kein manuelles Webhook-Setup nötig.
- pixx.io-App im Make-Store hinzufügen
- Modul wählen (z. B. „Neue Datei" als Trigger)
- Verbindung authentifizieren, Szenario bauen
Zapier
Keine eigene pixx.io-App — Anbindung über den generischen Webhook-Trigger „Webhooks by Zapier" plus HTTP-Action für Rückschreibungen.
- Zap mit Trigger „Webhooks by Zapier" (Catch Hook) anlegen
- Erzeugte URL als Webhook in pixx.io eintragen
- Logik bauen, am Ende HTTP-Action gegen die pixx.io API
n8n
Kein eigener pixx.io-Node — Anbindung über den integrierten „Webhook"-Node plus „HTTP Request"-Node. Ideal, wenn du selbst hosten willst.
- Workflow mit „Webhook"-Node als Trigger anlegen
- Erzeugte URL als Webhook in pixx.io eintragen
- Logik bauen, am Ende „HTTP Request"-Node gegen die API
Eigenes Skript
PHP, Python, Node.js/TypeScript oder jede andere Sprache — dein eigener Endpunkt für individuelle Logik, die in keiner Plattform sauber abzubilden ist.
- HTTPS-Endpunkt bauen (Sprache frei wählbar)
- Signatur prüfen, sofort mit 2xx antworten
- Verarbeitung asynchron auslagern, Ergebnis per API zurückschreiben
Eigene Skripte: volle Kontrolle, jede Sprache
Das Prinzip bleibt in jeder Sprache identisch: HTTPS-Endpunkt bereitstellen, Signatur prüfen, sofort mit 2xx antworten und die eigentliche Verarbeitung asynchron auslagern. Wähle deine Sprache:
<?php
declare(strict_types=1);
$secret = getenv('PIXXIO_WEBHOOK_SECRET');
$payload = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_PIXXIO_SIGNATURE'] ?? '';
$expected = hash_hmac('sha256', $payload, $secret);
if (!hash_equals($expected, $signature)) {
http_response_code(401);
exit('Invalid signature');
}
http_response_code(200); // sofort bestätigen, Verarbeitung folgt asynchron
$event = json_decode($payload, associative: true);
match ($event['event'] ?? '') {
'fileCreated' => Queue::push('ai-processing', $event),
'fileModifiedKeywordsAdded' => Queue::push('search-index-update', $event),
default => null,
};
// Queue::push() z. B. via Laravel Queues, Symfony Messenger
// oder einer eigenen Redis-/Datenbank-Warteschlange
import hashlib
import hmac
import os
from fastapi import FastAPI, Request, HTTPException, BackgroundTasks
app = FastAPI()
WEBHOOK_SECRET = os.environ["PIXXIO_WEBHOOK_SECRET"].encode()
def verify_signature(payload: bytes, signature: str) -> bool:
expected = hmac.new(WEBHOOK_SECRET, payload, hashlib.sha256).hexdigest()
return hmac.compare_digest(expected, signature)
async def process_event(event: dict) -> None:
# z. B. KI-Verarbeitung anstoßen, Ergebnis per API zurückschreiben
...
@app.post("/webhooks/pixxio")
async def receive_webhook(request: Request, background_tasks: BackgroundTasks):
payload = await request.body()
signature = request.headers.get("x-pixxio-signature", "")
if not verify_signature(payload, signature):
raise HTTPException(status_code=401, detail="Invalid signature")
background_tasks.add_task(process_event, await request.json())
return {"status": "accepted"} # sofort 200, Verarbeitung läuft im Hintergrund
import express from "express";
import crypto from "node:crypto";
const app = express();
app.use(express.raw({ type: "application/json" }));
const SECRET = process.env.PIXXIO_WEBHOOK_SECRET!;
function verifySignature(payload: Buffer, signature: string): boolean {
const expected = crypto.createHmac("sha256", SECRET).update(payload).digest("hex");
return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}
app.post("/webhooks/pixxio", (req, res) => {
const signature = req.header("x-pixxio-signature") ?? "";
if (!verifySignature(req.body, signature)) {
return res.status(401).send("Invalid signature");
}
res.status(200).send("OK"); // sofort bestätigen
const event = JSON.parse(req.body.toString("utf-8"));
queue.add("pixxio-event", event); // asynchron verarbeiten, z. B. via BullMQ
});
Egal welche Sprache — darauf kommt es an
- HTTPS-Endpunkt, öffentlich erreichbar
- Signatur (HMAC-SHA256) vor jeder Verarbeitung prüfen
- Schnell mit 2xx antworten, Verarbeitung asynchron auslagern (Queue, Background-Job)
- Idempotent verarbeiten — Events können theoretisch doppelt zugestellt werden
Wann welche Plattform?
… du schnell starten willst und vorgefertigte, gepflegte Module bevorzugst statt Webhook-Konfiguration von Hand.
… dein Team bereits im Zapier-Ökosystem arbeitet und Ziel-Apps anbinden möchte, die dort schon vorhanden sind.
… du selbst hosten, volle Kontrolle über Daten und Workflow-Logik haben oder Open Source bevorzugen möchtest.
… du sehr spezifische Logik brauchst, die in keiner Plattform sauber abzubilden ist. Siehe die Code-Beispiele oben.
Bereit zum Verbinden?
Starte mit der offiziellen Make-Integration oder richte dir in wenigen Minuten einen generischen Webhook für Zapier, n8n & Co. ein.