> 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 capacité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 aux Points de sortie 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, et exécute des appels d’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, ainsi que des applications personnalisées afin d’initier des actions automatisées selon 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 %}
### Fonctionnement des nœuds Webhook
Lorsque les données atteignent un nœud Webhook par une connexion entrante, celui-ci exécute immédiatement une requête HTTP POST vers le Point de sortie configuré. Le nœud :
1. Collecte les valeurs actuelles de tous les attributs à partir 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 sortie 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 s’effectue indépendamment, sans bloquer les autres nœuds du flux, ce qui garantit un traitement continu des données quels que soient les délais de réponse des systèmes externes.
Chaque **Webhook** résultat de 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 l’ **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 ne s’est pas déclenché et `1` lorsqu’il s’est déclenché, ce qui vous permet de confirmer la livraison et de distinguer plusieurs nœuds Webhook dans le même flux.
### Intégration à l'architecture du flux
Les nœuds Webhook font office de points de terminaison qui convertissent les données traitées des appareils en appels d’API externes. Plutôt que de diffuser en continu toutes les données des appareils comme les nœuds Point de sortie, les Webhooks exécutent des requêtes d’API ciblées avec des charges utiles configurées avec précision. Cette architecture permet :
* **Automatisations pilotées par les événements** : déclenchez des flux de travail externes selon les conditions des appareils, les métriques calculées ou des modèles 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** : fonctionne avec d’autres nœuds de sortie, ce qui permet le déclenchement simultané de Webhooks et la diffusion continue de données vers différentes destinations
* **Intégration de sources multiples** : accepte des connexions entrantes provenant de plusieurs branches parallèles et accède aux attributs de tous les nœuds connectés
### Capacités du nœud
Le **Nœud Webhook** offre :
* **Exécution HTTP POST** : envoie des requêtes HTTP POST personnalisées vers tout Point de sortie accessible utilisant les protocoles HTTP ou HTTPS (HTTPS recommandé)
* **Construction dynamique de la charge utile** : construit des corps de requête JSON combinant des valeurs statiques et des attributs dynamiques provenant de n’importe où dans le flux à l’aide de la `{{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 aux API
* **Prise en charge des attributs imbriqués** : référence des structures d’attributs complexes, y compris des objets et tableaux imbriqués dans la charge utile JSON
* **Exécution indépendante** : se déclenche sans attendre de réponses ni bloquer le flux, ce qui garantit 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 d’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 %}
#### Spécifiez le nom du nœud
Saisissez un nom descriptif qui identifie l’objectif du Webhook.
* Utilisez des noms qui indiquent le service ou l’action cible (par exemple, « Règles d’alertes de vitesse Slack » ou « Création de tickets CRM »)
* Ce nom apparaît dans le diagramme du flux pour être facilement identifié
{% 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 pas modifier sa valeur ni la définir.
* L’ID est généré automatiquement lorsque le nœud est créé et reste inchangé pendant toute la durée de vie du nœud
* Utilisez-le pour distinguer les résultats de ce nœud de ceux d’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 affichant `0` (non déclenché) ou `1` (déclenché)
{% endstep %}
{% step %}
#### Configurez l’URL du Point de sortie
Saisissez l’URL complète vers laquelle les requêtes POST sont envoyées.
* Incluez le protocole : `http://` ou `https://` (HTTPS fortement recommandé)
* Assurez-vous que l’URL pointe vers un Point de sortie d’API valide qui accepte les requêtes POST
* Exemple : `https://api.example.com/v1/webhooks/device-alerts`
{% endstep %}
{% step %}
#### Définir des 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 les en-têtes individuels
{% hint style="info" %}
Maximum de 10 en-têtes pris en charge
{% endhint %}
{% endstep %}
{% step %}
#### Construisez le corps de la requête
Passez à la **Corps** onglet et définissez la structure JSON qui est envoyée au point de terminaison :
* Saisissez une syntaxe JSON valide dans le champ Body
* Utilisez `{{attribute_name}}` pour référencer tout attribut provenant de 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 ex. : `{{location.latitude}}`)
* Si un attribut référencé est null ou n’existe pas, la valeur `null` est envoyé dans le JSON
**Exemple de corps du 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éponses du point de terminaison externe. La réussite ou l'échec de la requête Webhook n'affecte pas le fonctionnement continu 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 n’inclut pas de réessais automatiques, de journalisation des tentatives ayant échoué 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. Les futures mises à jour pourront inclure des limites de débit définies par la destination et la mise en file d’attente des requêtes.
{% endhint %}
### Webhook vs flux de données continu
**Nœud Webhook** diffère fondamentalement de **nœud Point de sortie** dans son objectif et son mode d’exécution :
| Nœud Webhook | nœud Point de sortie |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Exécute des appels d'API distincts à 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électionnées 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 analytiques 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 pilotées par des événements dans les systèmes qui fournissent des API REST. Les modèles d'intégration courants comprennent :
* **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 des appareils avec des plateformes de planification des ressources de l'entreprise afin de mettre à jour les niveaux de stock, de déclencher des flux de travail d'approvisionnement ou d'enregistrer l'utilisation des équipements pour l'ordonnancement de l'entretien
* **Systèmes de ticketing**: Créez automatiquement des tickets de support ou des demandes de service dans des plateformes CRM lorsque des problèmes de l’appareil sont détectés
* **Services d’alerte**: Déclenchez 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**: Lancez des flux de travail dans des outils comme Zapier, Make (Integromat) ou n8n à partir de la télémétrie de l’appareil
* **Systèmes télématiques**: Déclenchez des actions ou des automatisations spécifiques dans des solutions télématiques tierces sur la base de données traitées, en permettant des flux de travail pilotés par événements tels que 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 publiant 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’ **Logique** nœud permettant d’implémenter une 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 des configurations différentes 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 n’est pas disponible ou renvoie une erreur, le flux continue à s’exécuter normalement. Le webhook tente de se déclencher à nouveau à l’arrivée du prochain message. À l’heure actuelle, les tentatives de webhook ayant échoué ne sont pas consignées.
#### 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_jeton_ici`
* **Clés API**: Ajoutez les en-têtes personnalisés indiqués par votre fournisseur d’API
* **Authentification de base**: Ajoutez un en-tête `Authorization` avec la valeur `Basic base64_encoded_credentials`
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 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 les 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 par **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` est envoyé dans le JSON.
#### Comment puis-je tester ma configuration de webhook ?
Ouvrir [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 du nœud : sa valeur bascule sur `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’accéder 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 webhooks 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 by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
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 what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
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.
