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
- Dans votre dashboard, ouvrez Développeurs → Webhooks (propriétaire ou administrateur, offre Pro ou Enterprise).
- Indiquez l'URL HTTPS publique qui recevra les événements et choisissez les types d'événements (ou tous,
*). - Copiez le secret de signature
whsec_…: il n'est affiché qu'une seule fois. - 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
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
{
"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>
- Lisez le corps brut, tel que reçu, avant tout parsing JSON (un JSON ré-encodé ne donne pas la même signature).
- Extrayez
tet toutes les valeursv1de l'en-têteStrike-Signature. - Refusez la requête si
test écarté de plus de 300 secondes de votre horloge (protection contre le rejeu). - Calculez le HMAC attendu et comparez-le à chaque
v1avec une comparaison à temps constant. - 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 :
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é,
5xxou429: nouvelle tentative selon le calendrier ci-dessous. - Autre code
4xxou 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
200dè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 surStrike-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.trackedpeut 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.
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, une429ou une erreur réseau entraîne de nouvelles tentatives avec un délai croissant ; une autre4xxest définitive. - Dédoublonnez avec l'en-tête
X-Strike-Delivery(identique àdelivery_id). - URL publique uniquement, en
httpouhttps, 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.