Three routes, one principle
Automation platforms are technically built on the same foundation that custom scripts use too: webhooks for "pixx.io lets you know when something happens" and the REST API for "writing results back". The difference lies in how much of it is already pre-built:
- Make offers an official pixx.io app with ready-made modules — no manual webhook setup required.
- Zapier and n8n don't (currently) have a dedicated pixx.io app, but they connect just as reliably via the generic webhook trigger.
- The same principle works with virtually any platform that provides a webhook trigger and an HTTP module — such as Power Automate or Pabbly Connect.
Platforms compared
Make
Dedicated pixx.io app in the Make store with ready-made triggers and actions. The fastest way to get started — no manual webhook setup required.
- Add the pixx.io app from the Make store
- Choose a module (e.g. "New file" as a trigger)
- Authenticate the connection, build your scenario
Zapier
No dedicated pixx.io app — connect via the generic webhook trigger "Webhooks by Zapier" plus an HTTP action for write-backs.
- Create a Zap with the "Webhooks by Zapier" trigger (Catch Hook)
- Enter the generated URL as a webhook in pixx.io
- Build your logic, ending with an HTTP action against the pixx.io API
n8n
No dedicated pixx.io node — connect via the built-in "Webhook" node plus the "HTTP Request" node. Ideal if you want to self-host.
- Create a workflow with the "Webhook" node as the trigger
- Enter the generated URL as a webhook in pixx.io
- Build your logic, ending with an "HTTP Request" node against the API
Custom script
PHP, Python, Node.js/TypeScript or any other language — your own endpoint for bespoke logic that no platform can map cleanly.
- Build an HTTPS endpoint (in any language you like)
- Verify the signature, respond immediately with 2xx
- Offload processing asynchronously, write the result back via the API
Custom scripts: full control, any language
The principle is identical in every language: provide an HTTPS endpoint, verify the signature, respond immediately with 2xx and offload the actual processing asynchronously. Choose your language:
<?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); // confirm immediately, processing follows asynchronously
$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() e.g. via Laravel Queues, Symfony Messenger
// or your own Redis/database queue
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:
# e.g. trigger AI processing, write the result back via the API
...
@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"} # immediate 200, processing runs in the background
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"); // confirm immediately
const event = JSON.parse(req.body.toString("utf-8"));
queue.add("pixxio-event", event); // process asynchronously, e.g. via BullMQ
});
Whatever the language — here's what matters
- An HTTPS endpoint, publicly reachable
- Verify the signature (HMAC-SHA256) before any processing
- Respond quickly with 2xx, offload processing asynchronously (queue, background job)
- Process idempotently — events can, in theory, be delivered more than once
When to use which platform?
… you want to get started quickly and prefer ready-made, maintained modules over configuring webhooks by hand.
… your team already works within the Zapier ecosystem and wants to connect target apps that are already available there.
… you want to self-host, have full control over your data and workflow logic, or prefer open source.
… you need highly specific logic that no platform can map cleanly. See the code examples above.
Ready to connect?
Start with the official Make integration or set up a generic webhook for Zapier, n8n & Co. in just a few minutes.