Webhooks

Recevez les événements STRIKE en temps réel, signés et renvoyés en cas d’échec.

Les webhooks envoient une requête POST signée à votre serveur dès qu'un événement se produit dans STRIKE : nouveau lead, paiement encaissé, publication en ligne… Plus besoin d'interroger l'API en boucle.

Configurer un endpoint

  1. Dans votre dashboard, ouvrez Développeurs → Webhooks (propriétaire ou administrateur, offre Pro ou Enterprise).
  2. Indiquez l'URL HTTPS publique qui recevra les événements et choisissez les types d'événements (ou tous, *).
  3. Copiez le secret de signature whsec_… : il n'est affiché qu'une seule fois.
  4. Cliquez sur Tester pour recevoir un événement ping.

Vous pouvez aussi gérer vos endpoints par programme avec le scope webhooks:manage (voir Endpoints de webhooks) :

curl -X POST 'https://strikespace.net/api/platform/v1/webhook_endpoints' \
  -H "Authorization: Bearer $STRIKE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "url": "https://crm.example.com/strike/webhooks",
    "events": [
      "lead.created",
      "payment.succeeded"
    ],
    "description": "Synchronisation CRM"
  }'
// Node.js 18+ (fetch natif)
const response = await fetch('https://strikespace.net/api/platform/v1/webhook_endpoints', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.STRIKE_API_KEY}`,
    'Content-Type': 'application/json',
    'Idempotency-Key': crypto.randomUUID(),
  },
  body: JSON.stringify({
    "url": "https://crm.example.com/strike/webhooks",
    "events": [
      "lead.created",
      "payment.succeeded"
    ],
    "description": "Synchronisation CRM"
  }),
})
const data = await response.json()
if (!response.ok) throw new Error(`${data.error.type}: ${data.error.message}`)
console.log(data)
import os
import uuid
import requests

response = requests.post(
    "https://strikespace.net/api/platform/v1/webhook_endpoints",
    headers={"Authorization": f"Bearer {os.environ['STRIKE_API_KEY']}", "Idempotency-Key": str(uuid.uuid4())},
    json={
        "url": "https://crm.example.com/strike/webhooks",
        "events": ["lead.created", "payment.succeeded"],
        "description": "Synchronisation CRM",
    },
    timeout=10,
)
response.raise_for_status()
print(response.json())
<?php
$ch = curl_init('https://strikespace.net/api/platform/v1/webhook_endpoints');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('STRIKE_API_KEY'),
        'Content-Type: application/json',
        'Idempotency-Key: ' . bin2hex(random_bytes(16)),
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'url' => 'https://crm.example.com/strike/webhooks',
        'events' => ['lead.created', 'payment.succeeded'],
        'description' => 'Synchronisation CRM',
    ]),
]);
$body = json_decode(curl_exec($ch), true);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status >= 400) {
    throw new RuntimeException($body['error']['message'] ?? 'Erreur STRIKE');
}

5 endpoints maximum en Pro, 25 en Enterprise. L'URL doit être en HTTPS, sans identifiants, et désigner un hôte public : localhost, les noms .local / .internal ou sans domaine et les adresses IP privées sont refusés. L'adresse est revérifiée à chaque envoi (protection SSRF).

Catalogue des événements

Type data.object Déclenché quand
lead.created lead Un nouveau lead a été capté (tunnel, API, tracking ou intégration).
lead.updated lead Les informations, le statut ou les traits d’un lead ont changé.
lead.converted lead Un lead est passé au statut « converti » (achat ou mise à jour manuelle).
lead.deleted lead Un lead a été supprimé (seul son identifiant est envoyé).
event.tracked sur demande event Un événement de tracking a été enregistré. Volume élevé : jamais inclus dans « Tous les événements ». Volume élevé : jamais inclus dans « * », à cocher explicitement.
payment.succeeded payment Une vente réalisée via un tunnel a été payée.
payment.failed payment Le paiement d’une vente de tunnel a été refusé.
journey.enrollment.created journey_enrollment Un lead est entré dans un parcours automatisé.
journey.enrollment.completed journey_enrollment Un lead est arrivé au bout d’un parcours.
social.post.pending_approval social_post Une publication a été soumise pour validation.
social.post.scheduled social_post Une publication a été planifiée.
social.post.published social_post Une publication a été publiée sur au moins un réseau.
social.post.failed social_post La publication a échoué sur tous les réseaux visés.
ping ping Événement de test envoyé par le bouton « Tester ». Ne peut pas être choisi dans un abonnement.

data.object a exactement le même format que la ressource correspondante de l'API REST (par exemple l'objet lead). De nouveaux types d'événements peuvent être ajoutés : ignorez ceux que vous ne connaissez pas.

Format d'une livraison

HTTP
POST /strike/webhooks HTTP/1.1
Host: crm.example.com
Content-Type: application/json
User-Agent: StrikeSpace-Webhooks/1.0
Strike-Event-Id: evt_4Fz9kQ2LmN8pR1sT6vW3xY5z
Strike-Event-Type: lead.created
Strike-Delivery-Id: aab32389-22bc-4c0d-8e1f-2a3b4c5d6e74
Strike-Signature: t=1792145551,v1=5257a869e7ecebeda32affa62cdca3fa51cad7e77a0e56ff536d0ce8e108d8bd
Corps (JSON)
{
  "id": "evt_4Fz9kQ2LmN8pR1sT6vW3xY5z",
  "object": "event",
  "type": "lead.created",
  "created_at": "2026-10-16T10:05:51.000Z",
  "api_version": "2026-10-01",
  "workspace_id": "b6d767d2-f8ed-4c21-9a6f-3e4d5c6b7a85",
  "data": {
    "object": {
      "object": "lead",
      "id": "8f14e45f-ceea-4e7a-9a3b-2c1d5e6f7a80",
      "first_name": "Awa",
      "email": "awa@exemple.com",
      "phone_number": "+22997000000",
      "country_code": "BJ",
      "preferred_channel": "whatsapp",
      "status": "cold",
      "funnel_id": null,
      "traits": {
        "source": "crm"
      },
      "created_at": "2026-10-16T10:05:51.000Z"
    }
  }
}
En-tête Contenu
Strike-Event-Id Identifiant unique de l'événement (evt_…), identique au champ id et stable entre les renvois.
Strike-Event-Type Type de l'événement, identique au champ type.
Strike-Delivery-Id Identifiant de la livraison (une par endpoint et par événement), visible dans l'historique.
Strike-Signature t=<horodatage Unix>,v1=<signature> — voir ci-dessous.
User-Agent StrikeSpace-Webhooks/1.0

Vérifier la signature

Vérifiez chaque requête avant de la traiter : n'importe qui peut envoyer un POST à votre URL. La signature v1 est un HMAC-SHA256, encodé en hexadécimal, calculé avec votre secret whsec_… sur la chaîne :

<t>.<corps brut de la requête>
  1. Lisez le corps brut, tel que reçu, avant tout parsing JSON (un JSON ré-encodé ne donne pas la même signature).
  2. Extrayez t et toutes les valeurs v1 de l'en-tête Strike-Signature.
  3. Refusez la requête si t est écarté de plus de 300 secondes de votre horloge (protection contre le rejeu).
  4. Calculez le HMAC attendu et comparez-le à chaque v1 avec une comparaison à temps constant.
  5. Acceptez si au moins une signature correspond ; sinon répondez 400.
// Node.js 18+ / Express — vérification de la signature STRIKE
import crypto from 'node:crypto'
import express from 'express'

const TOLERANCE_SECONDS = 300
// Pendant une rotation, mettez l'ancien ET le nouveau secret.
const SECRETS = [process.env.STRIKE_WEBHOOK_SECRET]

export function verifyStrikeSignature(rawBody, header, secrets) {
  if (!header) return false
  const parts = header.split(',').map((part) => part.trim())
  const timestamp = Number(parts.find((part) => part.startsWith('t='))?.slice(2))
  const signatures = parts.filter((part) => part.startsWith('v1=')).map((part) => part.slice(3))
  if (!Number.isInteger(timestamp) || signatures.length === 0) return false
  if (Math.abs(Date.now() / 1000 - timestamp) > TOLERANCE_SECONDS) return false

  const signedPayload = `${timestamp}.${rawBody}`
  return secrets.some((secret) => {
    const expected = Buffer.from(crypto.createHmac('sha256', secret).update(signedPayload).digest('hex'))
    return signatures.some((signature) => {
      const received = Buffer.from(signature)
      return received.length === expected.length && crypto.timingSafeEqual(received, expected)
    })
  })
}

const app = express()

// Corps BRUT : ne laissez pas express.json() le réécrire avant la vérification.
app.post('/strike/webhooks', express.raw({ type: 'application/json' }), async (req, res) => {
  const rawBody = req.body.toString('utf8')
  if (!verifyStrikeSignature(rawBody, req.get('Strike-Signature'), SECRETS)) {
    return res.status(400).send('Signature invalide')
  }
  const event = JSON.parse(rawBody)
  if (await alreadyProcessed(event.id)) return res.sendStatus(200) // dédoublonnage
  await jobs.enqueue(event) // traitement asynchrone
  res.sendStatus(200) // répondez en moins de 10 s
})
<?php
// PHP 8+ — vérification de la signature STRIKE
const TOLERANCE_SECONDS = 300;

function verifyStrikeSignature(string $rawBody, ?string $header, array $secrets): bool
{
    if (!$header) {
        return false;
    }
    $timestamp = null;
    $signatures = [];
    foreach (explode(',', $header) as $part) {
        [$key, $value] = array_pad(explode('=', trim($part), 2), 2, '');
        if ($key === 't') {
            $timestamp = $value;
        } elseif ($key === 'v1') {
            $signatures[] = $value;
        }
    }
    if ($timestamp === null || !ctype_digit($timestamp) || !$signatures) {
        return false;
    }
    if (abs(time() - (int) $timestamp) > TOLERANCE_SECONDS) {
        return false;
    }
    foreach ($secrets as $secret) {
        $expected = hash_hmac('sha256', $timestamp . '.' . $rawBody, $secret);
        foreach ($signatures as $signature) {
            if (hash_equals($expected, $signature)) {
                return true;
            }
        }
    }
    return false;
}

$rawBody = file_get_contents('php://input');
$header = $_SERVER['HTTP_STRIKE_SIGNATURE'] ?? null;
// Pendant une rotation, mettez l'ancien ET le nouveau secret.
$secrets = [getenv('STRIKE_WEBHOOK_SECRET')];

if (!verifyStrikeSignature($rawBody, $header, $secrets)) {
    http_response_code(400);
    exit('Signature invalide');
}

$event = json_decode($rawBody, true);
// Dédoublonnez sur $event['id'], mettez le traitement en file, puis répondez vite.
http_response_code(200);
# Python 3.9+ / Flask — vérification de la signature STRIKE
import hashlib
import hmac
import os
import time

from flask import Flask, abort, request

TOLERANCE_SECONDS = 300
# Pendant une rotation, mettez l'ancien ET le nouveau secret.
SECRETS = [os.environ["STRIKE_WEBHOOK_SECRET"]]


def verify_strike_signature(raw_body: bytes, header: str | None, secrets: list[str]) -> bool:
    if not header:
        return False
    timestamp, signatures = None, []
    for part in header.split(","):
        key, _, value = part.strip().partition("=")
        if key == "t":
            timestamp = value
        elif key == "v1":
            signatures.append(value)
    if not timestamp or not timestamp.isdigit() or not signatures:
        return False
    if abs(time.time() - int(timestamp)) > TOLERANCE_SECONDS:
        return False
    signed_payload = timestamp.encode() + b"." + raw_body
    for secret in secrets:
        expected = hmac.new(secret.encode(), signed_payload, hashlib.sha256).hexdigest()
        if any(hmac.compare_digest(expected, signature) for signature in signatures):
            return True
    return False


app = Flask(__name__)


@app.post("/strike/webhooks")
def strike_webhook():
    raw_body = request.get_data()  # corps brut, avant tout parsing
    if not verify_strike_signature(raw_body, request.headers.get("Strike-Signature"), SECRETS):
        abort(400)
    event = request.get_json()
    # Dédoublonnez sur event["id"], mettez le traitement en file, puis répondez vite.
    return "", 200

Rotation du secret

Renouvelez le secret depuis le dashboard ou avec POST /webhook_endpoints/:id/rotate_secret. Pendant 24 heures, chaque livraison porte deux signatures v1, l'une avec le nouveau secret, l'autre avec l'ancien :

Pendant une rotation
Strike-Signature: t=1792145551,v1=<signature avec le nouveau secret>,v1=<signature avec l’ancien secret>

Ajoutez le nouveau secret à votre liste SECRETS, déployez, puis retirez l'ancien avant la date indiquée par secret_rotating_until sur l'endpoint. Aucune livraison n'est perdue pendant la transition.

Renvois et désactivation

Une livraison réussit quand votre serveur répond un code 2xx en moins de 10 secondes. Les redirections ne sont pas suivies.

  • Erreur réseau, délai dépassé, 5xx ou 429 : nouvelle tentative selon le calendrier ci-dessous.
  • Autre code 4xx ou redirection (3xx) : échec définitif, sans nouvelle tentative (vous pouvez la relancer manuellement).
Tentative Délai après la précédente
1 Immédiate
2 ≈ 1 minute
3 ≈ 5 minutes
4 ≈ 30 minutes
5 ≈ 2 heures
6 ≈ 6 heures
7 ≈ 12 heures (dernière tentative, ≈ 21 h après l’événement)

Après 20 livraisons consécutives en échec définitif, l'endpoint est désactivé automatiquement : le propriétaire du compte est prévenu par email et par un bandeau dans le dashboard. Corrigez votre serveur, puis réactivez l'endpoint depuis le dashboard ou avec PATCH /webhook_endpoints/:id et "status": "active".

L'historique des livraisons (statut, code HTTP, extrait de votre réponse, prochaine tentative) est conservé 30 jours. Une livraison peut être renvoyée depuis le dashboard (Renvoyer) ou avec POST /webhook_deliveries/:id/retry : cela crée une nouvelle livraison du même événement, avec le même Strike-Event-Id.

Bonnes pratiques

  • Répondez vite : renvoyez 200 dès la signature vérifiée et l'événement mis en file, puis traitez-le de façon asynchrone.
  • Dédoublonnez sur Strike-Event-Id (et non sur Strike-Delivery-Id) : un même événement peut vous parvenir plus d'une fois (renvoi après un délai dépassé, renvoi manuel).
  • Ne supposez pas l'ordre : les événements peuvent arriver dans le désordre. Comparez created_at, ou relisez la ressource par l'API pour obtenir son état actuel.
  • Vérifiez toujours la signature et l'horodatage ; gardez le secret dans un gestionnaire de secrets.
  • Abonnez-vous au strict nécessaire : event.tracked peut représenter un très gros volume.
  • Surveillez l'historique des livraisons pour détecter un endpoint en difficulté avant sa désactivation.

Tester en local

STRIKE n'envoie qu'à des URL publiques. Pendant le développement, exposez votre serveur local avec un tunnel HTTPS (par exemple ngrok ou Cloudflare Tunnel), enregistrez l'URL du tunnel comme endpoint, puis utilisez le bouton Tester ou POST /webhook_endpoints/:id/test : le ping est envoyé immédiatement et la réponse de votre serveur vous est retournée.

Action Webhook des parcours

Indépendamment des abonnements ci-dessus, l'action Webhook du Journey Builder envoie une requête POST en JSON à l'URL de votre choix lorsqu'un lead atteint cette étape d'un parcours, par exemple pour créer une tâche dans votre CRM.

Action Webhook d’un parcours
POST https://votre-outil.com/strike
Content-Type: application/json
User-Agent: StrikeSpace-Journeys/1.0
X-Strike-Delivery: <delivery_id>

{
  "type": "journey.action",
  "delivery_id": "<identifiant unique de l'envoi>",
  "lead": {
    "id": "…",
    "first_name": "Awa",
    "email": "awa@exemple.com",
    "phone_number": "+229…",
    "traits": { "plan": "pro" }
  },
  "trigger": { … }
}
  • Répondez par un code 2xx en moins de 10 secondes.
  • Nouvelles tentatives : une réponse 5xx, une 429 ou une erreur réseau entraîne de nouvelles tentatives avec un délai croissant ; une autre 4xx est définitive.
  • Dédoublonnez avec l'en-tête X-Strike-Delivery (identique à delivery_id).
  • URL publique uniquement, en http ou https, sans redirection ; les adresses privées ou locales sont refusées.

Les notifications des passerelles de paiement (FedaPay, CinetPay, Moneroo, Stripe) sont reçues directement par STRIKE : vous n'avez rien à configurer pour que vos paiements se mettent à jour. Abonnez-vous à payment.succeeded pour en être informé à votre tour.

Une question sur l'intégration ? Écrivez à contact@strike.app en indiquant l'endpoint, l'heure et le request_id de la réponse.