Regard de développeur : comment créer une synchronisation bidirectionnelle avec l'API Quire

Dernière mise à jour : 20 juillet 2026

Lorsque les données vivent dans deux applications, chaque action doit être effectuée deux fois, ou finit par se désynchroniser silencieusement. La synchronisation bidirectionnelle résout ce problème de double saisie en faisant échanger automatiquement les mises à jour entre Quire et l'autre application via des webhooks. L'API ouverte de Quire est conçue exactement pour ce cas d'usage.

Le coût des outils déconnectés est bien documenté. Selon l'étude de McKinsey sur l'économie sociale, les travailleurs du savoir passent près de 20 % de leur semaine à rechercher des informations internes au lieu d'accomplir leur travail réel. Une synchronisation fiable élimine automatiquement une bonne part de cette charge.

L'application de synchronisation bidirectionnelle Google Agenda en est l'exemple canonique : les tâches Quire et les événements Google Agenda restent alignés sans réconciliation manuelle. Cet article explique comment reproduire ce schéma avec l'API de n'importe quelle autre application.

La synchronisation bidirectionnelle Google Agenda est réservée aux souscriptions Premium et supérieures. Vous trouverez plus d'informations sur notre page tarifaire.

Quels sont les composants d'une synchronisation bidirectionnelle Quire ?

Quel est le fonctionnement de la synchronisation bidirectionnelle ?

Voyez la synchronisation bidirectionnelle comme une conversation entre deux applications. Lorsque vous mettez à jour une tâche dans Quire, celui-ci informe l'autre application du changement. Et lorsque quelque chose est mis à jour dans cette autre application, elle en informe Quire. Vos informations restent ainsi cohérentes partout.

Quelles sont les étapes d'implémentation ?

La première étape consiste à configurer votre application Quire. Vous devrez en créer une pour obtenir les identifiants nécessaires à l'accès à votre projet Quire via son API.

Pour un guide pas à pas sur la création de votre propre application avec l'API Quire, consultez notre article de blog.

Pour mettre en œuvre une synchronisation bidirectionnelle, vous devrez développer une application intermédiaire (votre application) servant de pont entre Quire et votre application cible (comme Google Agenda). Voyez-la comme un traducteur : elle récupère des informations d'un côté, les traite, puis envoie les bonnes commandes à l'autre. Le flux ressemble à ceci : Quire ↔ Votre application ↔ Autre application.

Comment la construire étape par étape ?

1. Préparer une application pour gérer les événements

Pour activer la synchronisation bidirectionnelle, vous devez d'abord mettre en place votre propre application serveur pour jouer le rôle de couche intermédiaire. Cette application sera chargée de recevoir les requêtes webhook POST provenant à la fois de Quire et de l'autre application. Votre serveur doit pouvoir :

• Accepter les requêtes HTTP POST entrantes (événements webhook) de Quire et de l'autre application.
• Analyser les charges utiles des événements et déterminer les actions à entreprendre.
• Utiliser les API respectives pour mettre à jour les données dans Quire ou dans l'autre application selon les besoins.

Vous pouvez construire cette application serveur avec la technologie de votre choix, comme Node.js, Python ou Ruby. Dans les sections suivantes, nous utiliserons Node.js pour illustrer un exemple simple de réception et de traitement des événements webhook. Assurez-vous que votre serveur est accessible depuis Internet afin que Quire et l'autre application puissent lui envoyer des événements webhook.

Voici un exemple simple en Node.js avec Express :

const express = require('express');
const app = express();
app.use(express.json());

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

2. Configurer un webhook dans Quire pour envoyer les mises à jour de tâche à votre application

Ensuite, vous devrez créer une route dans votre serveur pour recevoir les événements webhook de Quire.

app.post('/webhook', (req, res) => {
  console.log('Received webhook event:', req.body);
  // TODO: Handle the event and update Quire or other app via API
  res.status(200).send('Event received');
});

Dans cet exemple, la route du webhook est /webhook, l'URL complète sera donc ${your-host}/webhook.

Copiez cette URL de webhook et collez-la dans les paramètres de l'application Quire, afin que Quire sache où envoyer les notifications d'événements à votre application.

Par ailleurs, vous devrez enregistrer votre application Quire en tant que suiveur du projet que vous souhaitez synchroniser. Cela garantit que votre application reçoit les notifications pour les mises à jour pertinentes.

Pour un guide pas à pas sur la réception de notifications via l'API Quire, consultez notre guide.

3. Configurer un webhook dans l'autre application pour envoyer ses mises à jour à votre application

Pour synchroniser les mises à jour de l'autre application avec Quire, vous devrez également créer une route dans votre serveur pour recevoir les événements webhook de cette application. Le processus d'enregistrement est similaire à l'exemple montré ci-dessus pour Quire. Configurez simplement l'autre application pour qu'elle envoie ses notifications d'événements au point de terminaison webhook de votre application intermédiaire, et assurez-vous que votre serveur peut traiter correctement ces événements entrants.

4. Traiter les événements entrants et mettre à jour les données dans Quire et l'autre application via leurs API

Une fois que votre application reçoit des événements webhook de Quire et de l'autre application, vous devrez implémenter une logique pour traiter ces événements et synchroniser les données entre les deux plateformes. Cela implique généralement :

• Analyser les charges utiles des événements pour identifier ce qui a changé (par exemple, tâche créée, mise à jour ou supprimée). Pour plus de détails sur la structure des événements, consultez la documentation de l'API Quire - Événements de notification.
• Déterminer quels appels API sont nécessaires pour refléter ces changements dans l'autre application.
• Envoyer les requêtes API appropriées à Quire ou à l'autre application pour maintenir les données synchronisées.
• Maintenir une correspondance entre les ID de tâche Quire et les ID d'élément de votre application pour garantir que les mises à jour sont correctement liées.

En traitant soigneusement les événements entrants et en mettant à jour les données via les API, votre application garantit que les changements sont correctement répercutés des deux côtés, assurant une synchronisation bidirectionnelle fiable.

Voici un exemple utilisant Node.js et axios :

const axios = require('axios');

app.post('/webhook', (req, res) => {
  const { type } = req.body.data;
  // Reference of activity types: 
  // https://github.com/quire-api/quire-api/blob/master/docs/activity_types.md
  switch (type) {
    case 0: //Quire task created
      onQuireTaskCreate();
      break; 
    case 1: //Quire task deleted
      onQuireTaskDelete();
      break;
  }
  res.status(200).send('Event received');
});

// Route for handling events from another app to Quire
app.post('/anotherwebhook', async (req, res) => {
  const { isCreate, id, name, projectId } = req.body;
  if (isCreate) {
    // Create a task in the Quire project
    await axios.post(`https://quire.io/api/task/${projectId}`, { name });
    // Optionally, store the mapping between your app's id and Quire's task id
  } else {
    // Retrieve the corresponding Quire task id using your mapping logic
    const taskOid = getTaskIdByAppEventId(id, projectId);
    // Delete the task from the Quire project
    await axios.delete(`https://quire.io/api/task/${taskOid}`);
  }
  res.status(200).send('Event processed successfully');
});

Cet exemple montre comment traiter les événements de création et de suppression provenant d'une autre application et les synchroniser avec Quire. Veillez à implémenter une gestion des erreurs appropriée et à maintenir la table de correspondance des ID pour une synchronisation fiable.

Quels sont les points clés à retenir ?

Deux règles de sécurité couvrent les modes de défaillance qui touchent toute première implémentation :

• Suivez l'origine de chaque changement. Étiquetez les mises à jour déclenchées par votre processus de synchronisation et ignorez-les lorsqu'elles reviennent sous forme de webhook. Sans cela, Quire transmet le changement à l'autre application, celle-ci renvoie un webhook, votre serveur le répercute à nouveau, et la boucle se répète indéfiniment.
• Gardez des formats de données cohérents. Un champ qui a une signification dans Quire (une description en Markdown) peut nécessiter une conversion explicite avant de devenir une description d'événement d'agenda, une note de ticket en texte brut, ou tout autre format cible.

Quelle est la prochaine étape ?

L'API ouverte associée aux webhooks transforme Quire et vos autres outils en une source unique de vérité, plutôt qu'en deux sources concurrentes. Commencez par la synchronisation minimale viable (un type d'événement, une direction) et vérifiez que la boucle fonctionne de bout en bout avant de l'étendre.

À lire aussi : Intégrez des outils externes avec Quire via l'API Quire — avec n8n comme exemple — un exemple concret si vous préférez commencer par un outil d'automatisation sans code plutôt que par un serveur personnalisé.

Foire aux questions

Qu'est-ce que la synchronisation bidirectionnelle entre Quire et une autre application ?

Une connexion à double sens où les mises à jour circulent dans les deux directions : les changements dans Quire sont transmis à l'autre application, et les changements qui y sont effectués sont renvoyés vers Quire. L'application de synchronisation bidirectionnelle Google Agenda en est un exemple concret.

De quoi ai-je besoin pour créer une synchronisation bidirectionnelle avec l'API Quire ?

Une application Quire avec des identifiants API, un serveur intermédiaire accessible depuis Internet pour recevoir les webhooks, et une logique pour traduire les événements entre les deux API. N'importe quel langage backend convient.

Quel rôle joue l'application intermédiaire ?

Elle agit comme un traducteur entre Quire et l'autre service, reçoit les événements webhook, décide quels appels API effectuer, et maintient la correspondance entre les ID de tâche Quire et les ID d'élément de l'autre application.

Comment éviter les boucles de synchronisation infinies ?

Suivez l'origine de chaque changement et ignorez les mises à jour déclenchées par votre propre processus de synchronisation. Sans cette protection, chaque mise à jour rebondit indéfiniment entre les deux applications.

Quel plan Quire est requis pour la synchronisation bidirectionnelle avec Google Agenda ?

Premium et au-delà. Consultez les limites actuelles des niveaux sur la page tarifaire.