Intégration workflow

Webhooks

Recevez des événements HTTP POST sur votre propre point de terminaison à la fin des jobs de capture ou de lots. Les webhooks sont l’intégration la plus flexible — sans plateforme tierce obligatoire.

Événements

screenshot.finished

Job de capture unique terminé. Inclut URL de l’image, dimensions et métadonnées.

screenshot.failed

Échec du job après toutes les tentatives. Inclut la raison.

batch.finished

Tous les jobs du lot sont terminés. Résumé par job.

app.upload.finished

Une application de stockage a stocké la capture avec succès.

app.upload.failed

Échec du stockage après plusieurs tentatives. Relancez ou alertez depuis votre handler.

Comment ça marche

1

Ajouter une application Webhooks dans ScreenshotCenter

Allez dans Apps → Connect a new app → Webhooks. Indiquez l’URL du point de terminaison, les événements à souscrire et un secret pour la signature HMAC.
2

Inclure l’ID d’application dans les requêtes

Ajoutez l’ID d’application webhook au paramètre apps. À la fin du job, ScreenshotCenter envoie un POST HTTP vers votre URL.
3

Traiter la charge utile

Votre handler reçoit une charge JSON signée. Vérifiez l’en-tête X-ScreenshotCenter-Signature, puis traitez l’événement. Répondez en 2xx pour accuser réception.

Charge utile d’événement

Chaque événement est livré en POST signé avec un corps JSON :

POST https://your-server.com/webhooks/screenshot
Content-Type: application/json
X-ScreenshotCenter-Event: screenshot.finished
X-ScreenshotCenter-Signature: sha256=...

{
  "event": "screenshot.finished",
  "screenshot_id": "sc_abc123",
  "url": "https://example.com",
  "status": "finished",
  "image_url": "https://cdn.screenshotcenter.com/sc_abc123.png",
  "width": 1280,
  "height": 720,
  "created_at": "2026-02-22T14:30:00Z",
  "metadata": {}
}

Vérifier les signatures

ScreenshotCenter signe chaque webhook en HMAC-SHA256 avec votre secret. Vérifiez toujours la signature avant traitement :

import crypto from 'crypto';

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

// Express handler example
app.post('/webhooks/screenshot', (req, res) => {
  const sig = req.headers['x-screenshotcenter-signature'] as string;
  const raw = JSON.stringify(req.body);

  if (!verifyWebhook(raw, sig, process.env.WEBHOOK_SECRET!)) {
    return res.status(401).send('Invalid signature');
  }

  const { event, screenshot_id, image_url } = req.body;
  // handle event...
  res.sendStatus(200);
});

Exemple simple

Référencez votre application webhook dans le paramètre apps :

curl "https://api.screenshotcenter.com/api/v1/screenshot/create\
  ?key=YOUR_API_KEY\
  &url=https://example.com\
  &apps=my-webhook-app"

import { ScreenshotCenterClient } from 'screenshotcenter';

const client = new ScreenshotCenterClient(process.env.SCREENSHOTCENTER_API_KEY);

const shot = await client.screenshot.create('https://example.com', {
  apps: ['my-webhook-app'],
});

// Your endpoint receives a POST with the event payload

from screenshotcenter import ScreenshotCenterClient

client = ScreenshotCenterClient(api_key="YOUR_API_KEY")

shot = client.screenshot.create(
    "https://example.com",
    apps=["my-webhook-app"],
)

# Your endpoint receives a POST with the event payload

use ScreenshotCenter\Client;

$client = new Client(getenv('SCREENSHOTCENTER_API_KEY'));

$shot = $client->screenshot->create('https://example.com', [
    'apps' => ['my-webhook-app'],
]);

// Your endpoint receives a POST with the event payload

import sc "github.com/juliensobrier/screenshotcenter-go"

client := sc.New("YOUR_API_KEY")

client.Screenshot.Create("https://example.com", &sc.ScreenshotParams{
    Apps: []string{"my-webhook-app"},
})

// Your endpoint receives a POST with the event payload

require "screenshotcenter"

client = ScreenshotCenter::Client.new(ENV["SCREENSHOTCENTER_API_KEY"])

client.screenshot.create("https://example.com",
  apps: ["my-webhook-app"],
)

# Your endpoint receives a POST with the event payload

import io.screenshotcenter.ScreenshotCenterClient;
import io.screenshotcenter.models.*;
import java.util.List;

public class Main {
    public static void main(String[] args) throws Exception {
        var client = new ScreenshotCenterClient("YOUR_API_KEY");
        client.screenshot().create("https://example.com",
            new ScreenshotParams().apps(List.of("my-webhook-app")));
    }
}

using ScreenshotCenter;

var client = new ScreenshotCenterClient("YOUR_API_KEY");

await client.Screenshot.CreateAsync("https://example.com", new ScreenshotParams {
    Apps = new[] { "my-webhook-app" },
});

// Your endpoint receives a POST with the event payload

Fiabilité et nouvelles tentatives

Si votre point de terminaison renvoie autre chose qu’un 2xx ou expire, ScreenshotCenter réessaie avec backoff exponentiel — jusqu’à 5 tentatives. Vous pouvez suivre la livraison et relancer depuis les paramètres de l’application webhook.

Pour commencer

1. Créez un compte gratuit sur ScreenshotCenter.
2. Allez dans Apps → Connect a new app → Webhooks. Saisissez l’URL et un secret de signature.
3. Souscrivez aux événements nécessaires, enregistrez et copiez l’ID d’application.
4. Ajoutez l’ID au paramètre apps dans vos requêtes.
5. Vérifiez l’en-tête X-ScreenshotCenter-Signature et répondez 200 OK.

Commencer gratuitement Documentation API Toutes les intégrations