> For the complete documentation index, see [llms.txt](https://navixy.com/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/webhook-node.md).
# Webhook
Envoyez des requêtes HTTP POST à des API externes lorsqu'IoT Logic reçoit des données d'appareil. Créez des charges utiles JSON personnalisées avec des valeurs statiques et des attributs de télémétrie dynamiques.
## Vue d'ensemble technique et fonctionnalités
{% columns %}
{% column width="58.333333333333336%" %}
**Webhook** Le nœud permet le déclenchement en temps réel d'actions spécifiques dans des systèmes externes. Il envoie des requêtes HTTP POST vers les points de terminaison spécifiés lors de la réception de données provenant de nœuds connectés. Il construit ensuite des charges utiles JSON personnalisées avec des attributs statiques et dynamiques, puis exécute des appels API vers des services tiers.
{% endcolumn %}
{% column width="41.666666666666664%" %}
{% endcolumn %}
{% endcolumns %}
Le nœud étend les capacités d'IoT Logic au-delà du traitement et de la transmission des données, en permettant une intégration directe avec des plateformes de messagerie, des systèmes ERM et CRM, et des applications personnalisées afin de déclencher des actions automatisées en fonction de la configuration de votre flux.
{% hint style="info" %}
Les nœuds Webhook sont configurés séparément pour chaque flux dans l'interface utilisateur de la plateforme Navixy. Les nœuds Webhook servent de points terminaux dans un flux et nécessitent au moins une connexion entrante pour fonctionner. Ils ne peuvent pas transmettre de données aux nœuds suivants.
{% endhint %}
### Comment fonctionnent les nœuds Webhook
Lorsqu'un nœud Webhook reçoit des données via une connexion entrante, il exécute immédiatement une requête HTTP POST vers le point de terminaison configuré. Le nœud�a0:
1. Collecte les valeurs actuelles de tous les attributs des nœuds amont connectés
2. Remplace les références d'attributs dynamiques (par exemple, `{{speed}}`) par les valeurs réelles du message entrant
3. Construit la charge utile JSON complète en préservant la structure que vous avez définie
4. Envoie la requête HTTP POST avec les en-têtes spécifiés vers le point de terminaison cible
5. Continue sans attendre de réponse, ce qui permet au flux de se poursuivre immédiatement
Le Webhook se déclenche une fois pour chaque message qui l'atteint. Si plusieurs branches parallèles envoient des données au Webhook, il se déclenche séparément pour chaque message entrant. Cette exécution se déroule indépendamment, sans bloquer les autres nœuds du flux, ce qui garantit un traitement continu des données, quels que soient les temps de réponse du système externe.
Chaque **Webhook** résultat du déclenchement du nœud apparaît dans [Analyseur de données](/docs/user/fr/guide/account/iot-logic/data-stream-analyzer.md) sous la forme d'un attribut nommé d'après le **ID du nœud** (affiché dans la boîte de dialogue de configuration du nœud, par exemple `webhook_1a2b3c4d`). La valeur est `0` lorsque le nœud n'a pas été déclenché et `1` lorsqu'il a été déclenché, ce qui vous permet de confirmer la livraison et de distinguer plusieurs nœuds Webhook au sein du même flux.
### Intégration à l’architecture des flux
Les nœuds Webhook fonctionnent comme des points de terminaison qui convertissent les données d'appareil traitées en appels à des API externes. Plutôt que de diffuser en continu toutes les données d'appareil comme le font les nœuds Point de sortie, les webhooks exécutent des requêtes API ciblées avec des charges utiles configurées avec précision. Cette architecture permet�a0:
* **Automatisations déclenchées par des événements**: Déclenchez des flux de travail externes en fonction des conditions de l'appareil, des métriques calculées ou de schémas de données spécifiques identifiés plus tôt dans le flux
* **Transmission sélective des données**: Envoyez uniquement les attributs pertinents aux systèmes externes, ce qui réduit les transferts de données inutiles et les coûts d'API
* **Exécution parallèle**: Fonctionnez aux côtés d'autres nœuds de sortie, ce qui permet des déclenchements Webhook simultanés et un flux continu de données vers différentes destinations
* **Intégration multi-source**: Acceptez des connexions entrantes provenant de plusieurs branches parallèles et accédez aux attributs de tous les nœuds connectés
### Fonctionnalités du nœud
Le **Nœud Webhook** offre�a0:
* **Exécution HTTP POST**: Envoie des requêtes HTTP POST personnalisées vers n'importe quel point de terminaison accessible en utilisant les protocoles HTTP ou HTTPS (HTTPS recommandé)
* **Construction dynamique de la charge utile**: Construit des corps de requête JSON en combinant des valeurs statiques avec des attributs dynamiques provenant de n'importe où dans le flux en utilisant `{{attribute_name}}` syntaxe
* **Configuration d'en-têtes personnalisés**: Prend en charge jusqu'à 10 en-têtes HTTP définis par l'utilisateur pour l'authentification et les exigences spécifiques à l'API
* **Prise en charge des attributs imbriqués**: Permet de référencer des structures d'attributs complexes, y compris des objets et des tableaux imbriqués, dans la charge utile JSON
* **Exécution indépendante**: Se déclenche sans attendre de réponse ni bloquer le flux, ce qui permet un fonctionnement fiable quelle que soit la disponibilité du système externe
## Options de configuration
{% columns %}
{% column valign="middle" %}
Le nœud Webhook vous permet de définir la manière dont votre flux communiquera avec des systèmes externes via des appels à l'API HTTP.
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
Voyons quels éléments ce nœud utilise et ce que vous pouvez configurer lorsque vous travaillez avec lui.
### Étapes de configuration
{% stepper %}
{% step %}
#### Indiquez le nom du nœud
Saisissez un nom descriptif qui identifie la finalité du Webhook.
* Utilisez des noms qui indiquent le service ou l'action cible (par exemple, « Slack Speed Règles d’alertes » ou « Création de ticket CRM »)
* Ce nom apparaît dans le diagramme de flux pour faciliter l'identification
{% endstep %}
{% step %}
#### ID du nœud (généré automatiquement)
Sous le champ Nom, la boîte de dialogue affiche un **ID du nœud** (par exemple, `webhook_1a2b3c4d`). Ce champ est en lecture seule : vous ne pouvez ni modifier ni définir sa valeur.
* L'ID est généré automatiquement lors de la création du nœud et reste le même pendant toute la durée de vie du nœud
* Utilisez-le pour distinguer les résultats de ce nœud de ceux des autres nœuds Webhook dans [Analyseur de données](/docs/user/fr/guide/account/iot-logic/data-stream-analyzer.md), où il apparaît comme un attribut indiquant `0` (non déclenché) ou `1` (déclenché)
{% endstep %}
{% step %}
#### Configurez l'URL du point de terminaison
Saisissez l'URL complète vers laquelle les requêtes POST sont envoyées.
* Incluez le protocole�a0: `http://` ou `https://` (HTTPS fortement recommandé)
* Assurez-vous que l'URL pointe vers un point de terminaison API valide qui accepte les requêtes POST
* Exemple : `https://api.example.com/v1/webhooks/device-alerts`
{% endstep %}
{% step %}
#### Définir les en-têtes HTTP
Ajoutez tous les en-têtes requis par votre API cible.
1. Cliquez sur **Ajouter un en-tête** pour créer des paires clé-valeur d’en-tête\
Tous les en-têtes sont configurés par l’utilisateur, y compris Content-Type. Les en-têtes courants incluent :
* `Type de contenu : application/json` (obligatoire pour les charges utiles JSON)
* `Autorisation : Bearer ` (pour l’authentification API)
* Clés API personnalisées ou en-têtes d’authentification selon les exigences du service
2. Cliquez sur l’icône de suppression pour supprimer des en-têtes individuels
{% hint style="info" %}
10 en-têtes maximum pris en charge
{% endhint %}
{% endstep %}
{% step %}
#### Construisez le corps de la requête
Passez à l’ **Corps** onglet et définissez la structure JSON envoyée au point de terminaison :
* Saisissez une syntaxe JSON valide dans le champ Body
* Utilisez `{{attribute_name}}` pour faire référence à n’importe quel attribut des nœuds connectés
* Prend en charge les structures JSON imbriquées et les tableaux
* Les références d’attribut fonctionnent avec des chemins imbriqués (par exemple, `{{location.latitude}}`)
* Si un attribut référencé est nul ou n’existe pas, la valeur `null` est envoyé dans le JSON
**Exemple de corps de Webhook avec des attributs dynamiques :**
```json
{
"alert_type": "speed_violation",
"device_id": "{{device_id}}",
"current_speed": "{{speed_mph}}",
"threshold_exceeded": 80,
"location": {
"lat": "{{latitude}}",
"lng": "{{longitude}}"
},
"timestamp": "{{message_time}}",
"Conducteur": "{{hardware_key}}"
}
```
{% endstep %}
{% step %}
#### Enregistrez votre configuration
Cliquez sur **Appliquez les modifications** pour stocker les paramètres du nœud Webhook.
{% endstep %}
{% endstepper %}
## Comportement d'exécution du Webhook
Le Webhook s'exécute sans attendre de réponse du point de terminaison externe. Le succès ou l'échec de la requête Webhook n'affecte pas la poursuite du fonctionnement du flux et n'empêche pas les autres nœuds de traiter les données.
{% hint style="danger" %}
Actuellement, l'exécution du Webhook ne comprend pas de nouvelles tentatives automatiques, de journalisation des tentatives échouées ni de gestion des réponses. Si un point de terminaison renvoie une erreur ou expire, le Webhook se déclenchera de nouveau lors du prochain message entrant. De futures mises à jour pourraient inclure des limites de débit définies par la destination et une mise en file d'attente des requêtes.
{% endhint %}
### Webhook contre le flux continu de données
**Nœud Webhook** diffère fondamentalement de **Nœud Point de sortie** par son objectif et son mode d'exécution :
| Nœud Webhook | Nœud Point de sortie |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Exécute des appels API distincts sur chaque message, en envoyant les charges utiles personnalisées que vous définissez. Idéal pour déclencher des actions externes, envoyer des notifications ou transmettre des données sélectives vers des API REST. | Maintient des flux de données continus via MQTT, en transmettant les données complètes de l'appareil au format Navixy Generic Protocol. Conçu pour la collecte continue de télémétrie et la surveillance en temps réel. |
Choisissez les webhooks lorsque vous devez déclencher des automatisations externes ou envoyer uniquement des attributs spécifiques vers des points de terminaison d'API. Utilisez les points de terminaison de sortie pour des flux de données continus vers des plateformes d'analyse ou des systèmes de surveillance. Les deux peuvent coexister dans le même flux.
### Intégration avec des systèmes externes
Les nœuds Webhook excellent pour déclencher des actions événementielles dans des systèmes qui fournissent des API REST. Les schémas d'intégration courants comprennent�a0:
* **Plateformes de messagerie**: Envoyez des notifications à Slack, Microsoft Teams, WhatsApp ou Telegram lorsque les conditions de l'appareil répondent à des critères spécifiques
* **Systèmes ERP**: Synchronisez les données de l'appareil avec des plateformes de planification des ressources de l'entreprise afin de mettre à jour les niveaux de stock, de déclencher des workflows d'approvisionnement ou d'enregistrer l'utilisation de l'équipement pour l'ordonnancement de l'entretien
* **Systèmes de gestion des tickets**: Crée automatiquement des tickets d’assistance ou des demandes de service dans les plateformes CRM lorsque des problèmes d’appareil sont détectés
* **Services d’alerte**: Déclenche des notifications SMS, par e-mail ou push via des services comme Twilio, SendGrid ou Firebase lorsque les seuils sont dépassés
* **Automatisation métier**: Lance des flux de travail dans des outils comme Zapier, Make (Integromat) ou n8n en fonction de la télémétrie de l’appareil
* **Systèmes télématiques**: Déclenche des actions ou des automatisations spécifiques dans des solutions télématiques tierces à partir des données traitées, ce qui permet des flux de travail pilotés par les événements, comme des recalculs d’itinéraire, des notifications au conducteur ou des mises à jour de statut dans des systèmes externes de gestion de flotte
* **Applications personnalisées**: Activez une logique métier propriétaire en envoyant les événements de l’appareil vers des API internes
## Foire aux questions
#### Comment déclencher des webhooks uniquement dans des conditions spécifiques ?
Utilisez l'en-tête **Logique** nœud pour implémenter la logique conditionnelle avant le webhook. Le **Logique** nœud peut évaluer les attributs de l’appareil et acheminer les données vers le webhook uniquement lorsque les conditions sont remplies. Pour plus de détails, voir [Logique](/docs/user/fr/guide/account/iot-logic/nodes/logic-node.md).
#### Puis-je utiliser plusieurs nœuds Webhook dans le même flux ?
Oui. Incluez plusieurs **nœuds Webhook** avec différentes configurations pour déclencher divers systèmes externes à partir des mêmes données de l’appareil. Chaque webhook se déclenche indépendamment lorsqu’il reçoit des données.
#### Que se passe-t-il si la requête webhook échoue ?
Le webhook se déclenche sans attendre de réponse et ne réessaie pas automatiquement. Si le point de terminaison externe est indisponible ou renvoie une erreur, le flux continue de s’exécuter normalement. Le webhook tente de se déclencher à nouveau lorsque le message suivant arrive. Actuellement, il n’y a aucune journalisation des tentatives de webhook ayant échoué.
#### Comment vous authentifier auprès d’API externes ?
Configurez l’authentification entièrement via des en-têtes personnalisés. Approches courantes :
* **Jetons Bearer**: Ajoutez un en-tête `Authorization` avec la valeur `Bearer votre_token_ici`
* **Clés API**: Ajoutez des en-têtes personnalisés comme spécifié par votre fournisseur d’API
* **Authentification de base**: Ajoutez un en-tête `Authorization` avec la valeur `Basic identifiants_encodés_en_base64`
Incluez toujours `Type de contenu : application/json` en tant qu’en-tête lors de l’envoi de charges utiles JSON.
#### Puis-je référencer des attributs provenant de plusieurs nœuds connectés ?
Oui. Le nœud webhook peut accéder aux attributs de n’importe quel nœud connecté à lui, y compris des branches parallèles. Si plusieurs nœuds envoient des données au webhook, il se déclenche une fois pour chaque message entrant et peut référencer les attributs du chemin source de ce message.
#### Quelles données puis-je inclure dans le corps du webhook ?
Vous pouvez inclure n’importe quelle combinaison de :
* Valeurs statiques définies directement dans votre configuration JSON
* Attributs dynamiques du flux à l’aide de `{{attribute_name}}` syntaxe
* Attributs imbriqués provenant de structures de données complexes
* Attributs calculés dans **nœuds Initialiser un Attribut** ou traités via **Logique** nœuds
Le corps doit être un JSON valide. Si un attribut référencé n’existe pas ou contient une valeur nulle, `null` null est envoyé dans le JSON.
#### Comment puis-je tester ma configuration de webhook ?
Ouvrez [Analyseur de données](/docs/user/fr/guide/account/iot-logic/data-stream-analyzer.md) pour le flux et sélectionnez l’appareil déclencheur. Recherchez l’attribut correspondant à l’ID de ce nœud : sa valeur passe à `1` à chaque fois que le webhook se déclenche, `0` sinon. Cela confirme que le webhook s’est déclenché sans qu’il soit nécessaire d’avoir accès au point de terminaison de destination.
Pour vérifier que la destination a bien reçu la charge utile attendue, envisagez d’utiliser des services de test de webhook comme webhook.site ou RequestBin pendant le développement afin d’inspecter les requêtes exactes envoyées.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/webhook-node.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
