La visione di uno sviluppatore: come costruire la sincronizzazione bidirezionale con Quire API

Ultimo aggiornamento: 20 luglio 2026

Quando i dati vivono in due app, ogni azione viene svolta due volte oppure va silenziosamente fuori sincrono. La sincronizzazione bidirezionale risolve questo problema di doppia registrazione facendo scambiare automaticamente aggiornamenti tra Quire e l'altra app tramite webhooks. L'Open API di Quire è costruita esattamente per questo schema.

Il costo degli strumenti disconnessi è ben documentato. Secondo la ricerca di McKinsey sulla social economy, i knowledge worker dedicano quasi il 20% della settimana a rincorrere informazioni interne invece di svolgere il proprio lavoro effettivo. Una sincronizzazione affidabile elimina automaticamente una parte di questo carico.

L'app Google Calendar Two-Way Sync è l'esempio canonico: le attività di Quire e gli eventi di Google Calendar restano allineati senza riconciliazione manuale. Questo articolo illustra come costruire lo stesso schema con l'API di qualsiasi altra app.

Google Calendar Two-Way Sync è pensata per gli abbonamenti Premium e superiori. Maggiori informazioni sono disponibili sulla nostra pagina dei prezzi.

Quali sono i componenti di una sincronizzazione bidirezionale di Quire?

Qual è il flusso di lavoro della sincronizzazione bidirezionale?

Pensa alla sincronizzazione bidirezionale come a una conversazione tra due app. Quando aggiorni un'attività su Quire, questa comunica la modifica all'altra app. E quando qualcosa viene aggiornato su quell'altra app, questa lo comunica a Quire. In questo modo le tue informazioni restano coerenti ovunque.

Quali sono i passaggi di implementazione?

Il primo passo è configurare la tua app Quire. Dovrai crearne una per ottenere le credenziali necessarie ad accedere al tuo progetto Quire tramite la sua API.

Per una guida passo dopo passo su come creare la tua app con Quire API, visita il nostro articolo del blog.

Per implementare una sincronizzazione bidirezionale, dovrai sviluppare un'app di livello intermedio (la tua app) che funga da ponte tra Quire e l'app di destinazione (come Google Calendar). Pensala come un traduttore: riceverà informazioni da un lato, le elaborerà e poi invierà i comandi giusti all'altro lato. Il flusso è questo: Quire ↔ La tua app ↔ Altra app.

Come costruirla passo dopo passo?

1. Prepara un'app per la gestione degli eventi

Per abilitare la sincronizzazione bidirezionale, devi prima configurare un tuo server che funga da livello intermedio. Questa app sarà responsabile della ricezione delle richieste webhook POST sia da Quire sia dall'altra app. Il tuo server dovrebbe essere in grado di:

• Accettare richieste HTTP POST in arrivo (eventi webhook) da Quire e dall'altra app.
• Analizzare i payload degli eventi e determinare quali azioni intraprendere.
• Usare le rispettive API per aggiornare i dati su Quire o sull'altra app secondo necessità.

Puoi costruire questo server con qualsiasi tecnologia tu preferisca, come Node.js, Python o Ruby. Nelle sezioni seguenti useremo Node.js per mostrare un semplice esempio di ricezione e gestione degli eventi webhook. Assicurati che il tuo server sia accessibile da internet, in modo che Quire e l'altra app possano inviargli eventi webhook.

Ecco un semplice esempio in Node.js con Express:

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

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

2. Configura un webhook su Quire per inviare gli aggiornamenti delle attività alla tua app.

Successivamente, dovrai creare una route sul tuo server per ricevere gli eventi webhook da 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');
});

In questo esempio, la route del webhook è /webhook, quindi l'URL completo sarà ${your-host}/webhook.

Copia questo URL webhook e incollalo nelle impostazioni dell'app Quire, così Quire saprà dove inviare le notifiche di evento alla tua app.

Inoltre, dovrai registrare la tua app Quire come follower del progetto che vuoi sincronizzare. Questo assicura che la tua app riceva le notifiche per gli aggiornamenti rilevanti.

Per una guida passo dopo passo su come ricevere notifiche tramite Quire API, visita la nostra guida.

3. Configura un webhook sull'altra app per inviare i suoi aggiornamenti alla tua app.

Per sincronizzare gli aggiornamenti dell'altra app con Quire, dovrai anche creare una route sul tuo server per ricevere gli eventi webhook da quell'app. Il processo di registrazione è simile all'esempio mostrato sopra per Quire. Configura semplicemente l'altra app affinché invii le sue notifiche di evento all'endpoint webhook della tua app intermedia, e assicurati che il tuo server possa gestire ed elaborare correttamente questi eventi in arrivo.

4. Gestisci gli eventi in arrivo e aggiorna i dati sia su Quire sia sull'altra app usando le loro API.

Una volta che la tua app riceve eventi webhook sia da Quire sia dall'altra app, dovrai implementare la logica per elaborare questi eventi e sincronizzare i dati tra le due piattaforme. Questo comporta tipicamente:

• Analizzare i payload degli eventi per identificare cosa è cambiato (ad esempio, un'attività creata, aggiornata o eliminata). Per maggiori dettagli sulla struttura degli eventi, puoi consultare il documento API di Quire - Eventi di notifica.
• Determinare quali chiamate API sono necessarie per riflettere queste modifiche sull'altra app.
• Inviare le richieste API appropriate a Quire o all'altra app per mantenere i dati sincronizzati.
• Mantenere un mapping tra gli ID delle attività di Quire e gli ID degli elementi della tua app, per garantire che gli aggiornamenti siano collegati correttamente.

Gestendo con attenzione gli eventi in arrivo e aggiornando i dati tramite le API, la tua app assicura che le modifiche siano riflesse accuratamente su entrambi i lati, mantenendo una sincronizzazione bidirezionale affidabile.

Ecco un esempio con Node.js e 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');
});

Questo esempio mostra come gestire gli eventi di creazione ed eliminazione da un'altra app e sincronizzarli con Quire. Assicurati di implementare una corretta gestione degli errori e di mantenere il mapping degli ID per una sincronizzazione affidabile.

Quali sono le considerazioni chiave?

Due regole di sicurezza coprono le modalità di errore che colpiscono ogni prima implementazione:

• Tieni traccia dell'origine di ogni modifica. Etichetta gli aggiornamenti innescati dal tuo processo di sincronizzazione e ignorali quando rimbalzano indietro come webhook. Senza questo, Quire invia all'altra app, l'altra app attiva un webhook di ritorno, il tuo server invia di nuovo, e il loop si ripete all'infinito.
• Mantieni coerenti i formati dei dati. Un campo che significa una cosa su Quire (una descrizione in Markdown) potrebbe richiedere una conversione esplicita prima di diventare una descrizione di un evento del calendario, una nota testuale di un issue o un altro formato di destinazione.

Qual è il prossimo passo?

Open API più webhooks trasforma Quire e i tuoi altri strumenti in un'unica fonte di verità invece di due che competono tra loro. Inizia con la sincronizzazione più piccola possibile (un tipo di evento, una direzione) e verifica che il ciclo funzioni end-to-end prima di espanderlo.

Correlato: Integrare strumenti esterni con Quire tramite Quire API — Usando n8n come esempio — un esempio pratico se preferisci partire da uno strumento di automazione no-code invece che da un server personalizzato.

Domande frequenti

Cos'è la sincronizzazione bidirezionale tra Quire e un'altra app?

Una connessione a doppio senso in cui gli aggiornamenti fluiscono in entrambe le direzioni: le modifiche su Quire vengono inviate all'altra app, e le modifiche lì vengono rimandate a Quire. L'app Google Calendar Two-Way Sync è un esempio funzionante.

Cosa mi serve per costruire una sincronizzazione bidirezionale con Quire API?

Un'app Quire con credenziali API, un server di livello intermedio raggiungibile da internet per ricevere i webhooks, e una logica per tradurre gli eventi tra le due API. Funziona con qualsiasi linguaggio di backend.

Che ruolo svolge l'app di livello intermedio?

Agisce da traduttore tra Quire e l'altro servizio, ricevendo eventi webhook, decidendo quali chiamate API effettuare e mantenendo il mapping tra gli ID delle attività di Quire e gli ID degli elementi dell'altra app.

Come posso evitare loop di sincronizzazione infiniti?

Tieni traccia dell'origine di ogni modifica e ignora gli aggiornamenti innescati dal tuo stesso processo di sincronizzazione. Senza questa protezione, ogni aggiornamento rimbalza tra le due app all'infinito.

Quale piano Quire è necessario per Google Calendar Two-Way Sync?

Premium e superiori. Verifica i limiti attuali dei livelli sulla pagina dei prezzi.