> 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 à la réception de données provenant des 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%" %}

<figure><img src="https://2196179364-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F446mKak1zDrGv70ahuYZ%2Fuploads%2Fgit-blob-0b4156bcc8f11f49a91ad380aa20bf05842c617b%2Fiot-logic-webhook-tile.png?alt=media" alt=""><figcaption></figcaption></figure>
{% 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 pour 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 %}

<figure><img src="https://2196179364-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F446mKak1zDrGv70ahuYZ%2Fuploads%2Fgit-blob-21ecc9198943832f7ef089cac12b989f3aa37aec%2Fiot-logic-webhook-in-flow.png?alt=media" alt=""><figcaption></figcaption></figure>

### Comment fonctionnent les nœuds Webhook

Lorsque des données atteignent un nœud Webhook via une connexion entrante, celui-ci exécute immédiatement une requête HTTP POST vers le point de terminaison configuré. Le nœud :

1. Collecte les valeurs actuelles de tous les attributs provenant des nœuds amont connectés
2. Remplace les références aux attributs dynamiques (par exemple, `{{speed}}`) par les valeurs réelles du message entrant
3. Construit la charge utile JSON complète en conservant 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. Se poursuit sans attendre de réponse, ce qui permet au flux de continuer 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 de déclenchement du nœud apparaît dans [Analyseur de données](https://navixy.com/docs/user/fr/guide/account/iot-logic/data-stream-analyzer.md) sous forme d'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 réception et de distinguer plusieurs nœuds Webhook au sein du même flux.

### Intégration à l’architecture du flux

Les nœuds Webhook servent de points de terminaison qui transforment les données d’appareils traitées en appels API externes. Plutôt que de diffuser en continu toutes les données d’appareils comme les nœuds Point de sortie, les webhooks exécutent des requêtes API ciblées avec des charges utiles précisément configurées. Cette architecture permet :

* **Automatisations déclenchées par des événements**: Déclenchez des flux de travail externes en fonction des conditions des appareils, 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, en réduisant le transfert de données inutile et les coûts d’API
* **Exécution parallèle**: Fonctionnez aux côtés d’autres nœuds de sortie, en permettant des déclenchements Webhook simultanés et une diffusion continue des données vers différentes destinations
* **Intégration multisource**: 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 bloc **Le nœud Webhook** offre :

* **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 combinant des valeurs statiques avec des attributs dynamiques provenant de n’importe où dans le flux en utilisant `{{attribute_name}}` la 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 de l’API
* **Prise en charge des attributs imbriqués**: Permet de faire référence à des structures d’attributs complexes, notamment des objets et des 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 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 comment votre flux communiquera avec des systèmes externes au moyen d’appels à des API HTTP.
{% endcolumn %}

{% column %}

<figure><img src="https://2196179364-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F446mKak1zDrGv70ahuYZ%2Fuploads%2Fgit-blob-11bf6de89a59cf76114222886657ad0d1edcd308%2FWebhook_node_edit.png?alt=media" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

Voyons quels éléments ce nœud utilise et ce que vous pouvez configurer lors de son utilisation.

### É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 cible ou l’action (par exemple, « Alertes de vitesse Slack » ou « Création de ticket CRM »)
* Ce nom apparaît dans le diagramme du flux pour une identification facile
  {% 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 le modifier ni en définir la valeur.

* L'ID est généré automatiquement lors de la création du nœud 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 des autres nœuds Webhook dans [Analyseur de données](https://navixy.com/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 terminaison

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 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 :
   * `Content-Type: application/json` (requis pour les charges utiles JSON)
   * `Authorization: Bearer <token>` (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" %}
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 qui est envoyée au point de terminaison :

* Saisissez une syntaxe JSON valide dans le champ Body
* À utiliser `{{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’attributs 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 **Appliquer 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 n’inclut 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 dépasse le délai d’attente, le Webhook sera déclenché 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

**Le nœud Webhook** diffère fondamentalement de **Nœud Point de sortie** en termes d’objectif et de schéma d’exécution :

| Le nœud Webhook                                                                                                                                                                                                                                         | Nœud Point de sortie                                                                                                                                                                                                                   |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Exécute des appels API distincts pour chaque message, en envoyant des 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 à des API REST. | Maintient des flux de données continus via MQTT, en transmettant des données complètes sur les appareils au format Navixy Generic Protocol. Conçu pour la collecte continue de données télémétriques 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 à des points de terminaison d'API. Utilisez des 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 sont particulièrement efficaces pour déclencher des actions pilotées par des événements dans des systèmes qui fournissent des API REST. Les modèles d'intégration courants incluent :

* **Plateformes de messagerie** : Envoyez des notifications à Slack, Microsoft Teams, WhatsApp ou Telegram lorsque les conditions des appareils répondent à des critères spécifiques
* **Systèmes ERP** : Synchronisez les données des appareils avec des plateformes de planification des ressources d'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 gestion des tickets**�A0: Créer automatiquement des tickets d’assistance ou des demandes de service dans des plateformes CRM lorsque des problèmes d’appareil sont détectés
* **Services d’alerte**�A0: Déclencher des SMS, des e-mails ou des notifications push via des services comme Twilio, SendGrid ou Firebase lorsque les seuils sont dépassés
* **Automatisation métier**�A0: Initialiser 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**�A0: Déclencher des actions ou des automatisations spécifiques dans des solutions télématiques tierces en fonction des données traitées, ce qui permet des flux de travail pilotés par les événements, tels que les recalculs d’itinéraire, les notifications au conducteur ou les mises à jour de statut dans des systèmes externes de gestion de flotte
* **Applications personnalisées**�A0: Activer une logique métier propriétaire en envoyant les événements de l’appareil à des API internes

## Questions fréquemment posées

#### Comment puis-je déclencher des webhooks uniquement dans des conditions spécifiques�A0?

Utilisez la **Logique** nœud permettant d’implémenter une logique conditionnelle avant le webhook. Le **Logique** Le nœud peut évaluer les attributs de l’appareil et acheminer les données d’itinéraire vers le webhook uniquement lorsque les conditions sont remplies. Pour plus de détails, voir [Logique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/logic-node.md).

#### Puis-je utiliser plusieurs nœuds Webhook dans le même flux�A0?

Oui. Incluez plusieurs **nœuds Webhook** avec des configurations différentes pour déclencher divers systèmes externes à partir des mêmes données d’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�A0?

Le webhook se déclenche sans attendre de réponse et n’effectue pas de nouvelle tentative automatiquement. Si le point de terminaison externe est indisponible ou renvoie une erreur, le flux poursuit le traitement normalement. Le webhook tente de se déclencher à nouveau à l’arrivée du message suivant. À l’heure actuelle, les tentatives de webhook ayant échoué ne sont pas consignées.

#### Comment puis-je m’authentifier auprès d’API externes�A0?

Configurez l’authentification entièrement via des en-têtes personnalisés. Approches courantes�A0:

* **Jetons Bearer**�A0: Ajoutez l’en-tête `Authorization` avec la valeur `Bearer your_token_here`
* **Clés API**�A0: Ajoutez des en-têtes personnalisés comme spécifié par votre fournisseur d’API
* **Authentification Basic**�A0: Ajoutez l’en-tête `Authorization` avec la valeur `Basic base64_encoded_credentials`

Incluez toujours `Content-Type: application/json` comme 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�A0?

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�A0?

Vous pouvez inclure n’importe quelle combinaison de�A0:

* Valeurs statiques définies directement dans votre configuration JSON
* d’attributs dynamiques provenant du flux à l’aide de `{{attribute_name}}` la syntaxe
* Attributs imbriqués provenant de structures de données complexes
* d’attributs calculés dans **nœuds Initialiser un Attribut** ou traités par **Logique** des 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 webhook�A0?

Ouvrir [Analyseur de données](https://navixy.com/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�A0: 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’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 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 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=<question>&goal=<user_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.
