Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

Connecteur Zapier

Statut du connecteur: Prévu Pas encore construit. Tajo n'exécute pas ce connecteur aujourd'hui.

Illustration · données d’exemple

Exemple de synchronisation

Vérifier un enregistrement

Source

Zapier

Statut du connecteur: Prévu

Destination

Votre autre outil

Statut du connecteur: Outil personnalisé

Correspondance des champs

Champ source	Champ de destination	Valeur d’exemple
`record.id`	`source_id`	`record_1042`
`record.updated_at`	`updated_at`	`2026-10-18T08:00:00Z`
`record.value`	`value`	`sample_value`

Préparer
Vérifier un enregistrement
Approuver cette version

Les statuts concernent chaque connecteur et ne garantissent pas que cette synchronisation soit prête. Champs illustratifs. Vérifiez le schéma réel et les autorisations avant toute synchronisation.

Connectez Zapier à Brevo via Tajo pour relier des milliers d’applications tierces à vos workflows d’automatisation marketing, permettant des flux de données sans code et des déclencheurs événementiels dans toute votre stack technique.

Vue d’ensemble

Propriété	Valeur
Plateforme	Zapier
Catégorie	Automatisation (Personnalisé)
Complexité de configuration	Facile
Intégration officielle	Non
Données synchronisées	Événements, Contacts, Workflows, Déclencheurs
Méthode d’authentification	Clé API / OAuth 2.0

Fonctionnalités

Orchestration multi-applications - Connectez 6 000+ applications à Brevo via des workflows Zap
Déclencheurs webhook - Recevez des événements en temps réel depuis n’importe quelle application connectée à Zapier
Synchronisation des contacts - Envoyez et récupérez des contacts entre les plateformes connectées à Zapier et Brevo
Transfert d’événements - Acheminez les événements applicatifs via Tajo vers les automatisations Brevo
Zaps multi-étapes - Créez des workflows complexes avec filtres, formateurs et délais
Application Zapier personnalisée - Utilisez le Zapier Platform CLI pour créer des intégrations sur mesure

Prérequis

Avant de commencer, assurez-vous d’avoir :

Un compte Zapier (niveau gratuit ou supérieur)
Un compte Brevo avec accès API
Un compte Tajo avec permissions de connecteur
Node.js 18+ installé (pour le développement d’intégrations via CLI)

Authentification

Authentification par clé API

# Définissez vos identifiants Zapier Platform
export ZAPIER_DEPLOY_KEY=your_deploy_key
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key

OAuth 2.0

Zapier prend en charge OAuth 2.0 pour connecter des services tiers dans les Zaps :

const authentication = {
  type: 'oauth2',
  oauth2Config: {
    authorizeUrl: {
      url: 'https://your-app.com/oauth/authorize',
      params: {
        client_id: '{{process.env.CLIENT_ID}}',
        state: '{{bundle.inputData.state}}',
        redirect_uri: '{{bundle.inputData.redirect_uri}}',
        response_type: 'code'
      }
    },
    getAccessToken: {
      url: 'https://your-app.com/oauth/token',
      method: 'POST',
      body: {
        code: '{{bundle.inputData.code}}',
        client_id: '{{process.env.CLIENT_ID}}',
        client_secret: '{{process.env.CLIENT_SECRET}}',
        grant_type: 'authorization_code',
        redirect_uri: '{{bundle.inputData.redirect_uri}}'
      }
    },
    refreshAccessToken: {
      url: 'https://your-app.com/oauth/token',
      method: 'POST',
      body: {
        refresh_token: '{{bundle.authData.refresh_token}}',
        client_id: '{{process.env.CLIENT_ID}}',
        client_secret: '{{process.env.CLIENT_SECRET}}',
        grant_type: 'refresh_token'
      }
    }
  }
};

Configuration

Configuration de base

connectors:
  zapier:
    enabled: true
    webhook_url: "https://hooks.zapier.com/hooks/catch/YOUR_HOOK_ID"

    sync:
      contacts: true
      events: true
      workflows: true

    triggers:
      - contact_created
      - order_placed
      - form_submitted

    mapping:
      email: email
      first_name: FIRSTNAME
      last_name: LASTNAME

Configuration des webhooks

Configurez Tajo pour envoyer des événements vers les webhooks Zapier :

webhooks:
  zapier:
    url: "https://hooks.zapier.com/hooks/catch/YOUR_HOOK_ID"
    events:
      - contact.created
      - contact.updated
      - order.completed
      - cart.abandoned
    retry:
      max_attempts: 3
      backoff: exponential

Endpoints API

Endpoint	Méthode	Description
`https://hooks.zapier.com/hooks/catch/{id}`	POST	Hook de capture webhook
`https://nla.zapier.com/api/v1/dynamic/exposed/`	GET	Lister les actions exposées
`https://nla.zapier.com/api/v1/dynamic/exposed/{action_id}/execute/`	POST	Exécuter une action
`https://zapier.com/api/platform/cli/apps`	GET	Lister les applications enregistrées
`https://zapier.com/api/platform/cli/push`	POST	Déployer l’intégration

Exemples de code

Initialiser le connecteur

import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

// Connecter Zapier via webhook
await tajo.connectors.connect('zapier', {
  webhookUrl: process.env.ZAPIER_WEBHOOK_URL,
  events: ['contact.created', 'order.completed']
});

Créer une intégration Zapier personnalisée avec Platform CLI

const { version: platformVersion } = require('zapier-platform-core');

const App = {
  version: require('./package.json').version,
  platformVersion,
  authentication,
  triggers: {
    new_contact: {
      key: 'new_contact',
      noun: 'Contact',
      display: {
        label: 'New Contact in Tajo',
        description: 'Triggers when a new contact is synced.'
      },
      operation: {
        perform: async (z, bundle) => {
          const response = await z.request({
            url: 'https://api.example.com/v1/contacts',
            params: { since: bundle.meta.lastPoll }
          });
          return response.data;
        }
      }
    }
  },
  creates: {
    sync_contact: {
      key: 'sync_contact',
      noun: 'Contact',
      display: {
        label: 'Sync Contact to Brevo',
        description: 'Syncs a contact to Brevo via Tajo.'
      },
      operation: {
        inputFields: [
          { key: 'email', required: true, type: 'string' },
          { key: 'firstName', type: 'string' },
          { key: 'lastName', type: 'string' }
        ],
        perform: async (z, bundle) => {
          const response = await z.request({
            method: 'POST',
            url: 'https://api.example.com/v1/contacts/sync',
            body: bundle.inputData
          });
          return response.data;
        }
      }
    }
  }
};

module.exports = App;

Caution

L’adresse example.com ci-dessus est un exemple provisoire en attendant que l’endpoint Tajo soit disponible.

Gérer les webhooks Zapier entrants

app.post('/webhooks/zapier', async (req, res) => {
  const { event, data } = req.body;

  await tajo.connectors.handleWebhook('zapier', {
    topic: event,
    payload: data
  });

  res.status(200).json({ status: 'received' });
});

Limites de taux

Plan	Requêtes	Tâches/Mois	Intervalle de polling
Free	100/jour	100	15 min
Starter	1 000/jour	750	15 min
Professional	5 000/jour	2 000	2 min
Team	10 000/jour	50 000	1 min

Limites de tâches Zapier

Chaque étape de Zap compte comme une tâche. Les Zaps multi-étapes consomment plusieurs tâches par exécution. Surveillez votre consommation de tâches dans le tableau de bord Zapier pour éviter les dépassements.

Dépannage

Problème	Cause	Solution
Webhook ne se déclenche pas	Zap désactivé	Vérifiez le statut du Zap dans le tableau de bord Zapier
Données non mappées	Nom de champ incorrect	Vérifiez la correspondance des clés de champs entre les applications
Contacts dupliqués	Déduplication non configurée	Activez la déduplication basée sur l’email dans Tajo
Erreurs Zap	Limite de taux API atteinte	Ajoutez des étapes de délai ou mettez à niveau le plan Zapier
Auth expirée	Jeton non rafraîchi	Réauthentifiez la connexion dans Zapier

Mode debug

connectors:
  zapier:
    debug: true
    log_level: verbose
    log_webhooks: true

Bonnes pratiques

Privilégiez les webhooks au polling - Les webhooks offrent un flux de données en temps réel vs les délais du polling
Ajoutez la gestion d’erreurs - Utilisez les Zapier Paths pour gérer les scénarios de succès/échec
Dédupliquez les données - Activez les clés de déduplication pour éviter les enregistrements dupliqués
Surveillez la consommation de tâches - Configurez des alertes avant d’atteindre les limites de tâches
Utilisez les filtres judicieusement - Filtrez tôt dans les Zaps pour réduire la consommation inutile de tâches
Versionnez vos intégrations CLI - Utilisez le versioning sémantique pour les applications Platform CLI

Sécurité

HTTPS uniquement - Toutes les URLs de webhooks doivent utiliser HTTPS
Rotation des clés API - Faites tourner les clés périodiquement via le tableau de bord Zapier
OAuth 2.0 - Utilisez OAuth pour l’authentification des services tiers
Vérification des webhooks - Validez les signatures des webhooks entrants
Permissions à périmètre réduit - Accordez l’accès minimal requis par Zap