Connecteur Salesforce

Connecteur Salesforce

Connectez votre CRM Salesforce à Brevo via Tajo pour une synchronisation de contacts de niveau entreprise, la gestion des leads, le suivi des opportunités et une automatisation marketing alimentée par les données de votre CRM.

Vue d’ensemble

Fonctionnalités

• Synchronisation bidirectionnelle contact/lead, Synchronisez les contacts et leads Salesforce avec les listes de contacts Brevo
• Suivi des opportunités, Mappez les étapes de transaction et les montants pour une segmentation basée sur le chiffre d’affaires
• Hiérarchie des comptes, Synchronisez les comptes d’entreprise pour l’Account-Based Marketing dans Brevo
• Mappage des objets personnalisés, Mappez les objets personnalisés Salesforce vers des attributs et événements Brevo
• Synchronisation des membres de campagne, Synchronisez les membres de campagne Salesforce avec les listes Brevo
• Suivi des activités, Synchronisez tâches, événements et activités e-mail pour le scoring d’engagement
• Streaming en temps réel, Utilisez l’API Streaming Salesforce pour des mises à jour instantanées
• Prise en charge des requêtes SOQL, Filtrez les données synchronisées avec des requêtes SOQL personnalisées

Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Une org Salesforce (toute édition avec accès API)
2. Une Connected App configurée dans Salesforce Setup
3. L’accès API activé pour votre profil utilisateur Salesforce
4. Un compte Brevo avec accès API
5. Un compte Tajo

Authentification

Flux OAuth 2.0 Web Server (recommandé)

Idéal pour les intégrations en production avec autorisation utilisateur.

# Step 1: Authorize
https://login.salesforce.com/services/oauth2/authorize?
  response_type=code&
  client_id={consumer_key}&
  redirect_uri={callback_url}

# Step 2: Exchange code for tokens
curl -X POST https://login.salesforce.com/services/oauth2/token \
  -d "grant_type=authorization_code" \
  -d "code={auth_code}" \
  -d "client_id={consumer_key}" \
  -d "client_secret={consumer_secret}" \
  -d "redirect_uri={callback_url}"

Flux Username-Password

Pour les intégrations serveur à serveur sans interaction utilisateur.

curl -X POST https://login.salesforce.com/services/oauth2/token \
  -d "grant_type=password" \
  -d "client_id={consumer_key}" \
  -d "client_secret={consumer_secret}" \
  -d "username={username}" \
  -d "password={password}{security_token}"

Configuration

Configuration de base

connectors:
  salesforce:
    enabled: true
    instance_url: "https://yourorg.my.salesforce.com"
    api_version: "v59.0"
    auth:
      type: oauth2
      consumer_key: "${SF_CONSUMER_KEY}"
      consumer_secret: "${SF_CONSUMER_SECRET}"
      refresh_token: "${SF_REFRESH_TOKEN}"

    # Data sync options
    sync:
      contacts: true
      leads: true
      accounts: true
      opportunities: true
      campaigns: true

    # Sync direction
    direction: salesforce_to_brevo

    # Brevo list assignment
    lists:
      all_leads: 15
      qualified_leads: 16
      customers: 17

Mappage des champs

Mappez les champs Salesforce vers les attributs de contact Brevo :

Mappage des champs personnalisés

field_mapping:
  # Standard fields
  Email: email
  FirstName: FIRSTNAME
  LastName: LASTNAME
  Phone: SMS

  # CRM fields
  LeadSource: LEAD_SOURCE
  Lead_Score__c: LEAD_SCORE
  Account.Name: COMPANY_NAME
  Account.Industry: INDUSTRY

  # Opportunity fields
  Amount: DEAL_VALUE
  StageName: DEAL_STAGE
  CloseDate: EXPECTED_CLOSE_DATE

  # Custom fields
  Preferred_Channel__c: PREFERRED_CHANNEL
  Customer_Tier__c: VIP_TIER

Endpoints API

Ressources REST API

Bulk API

Streaming API

Événements

Événements d’enregistrement (Change Data Capture)

Platform Events

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
});

// Connect Salesforce
await tajo.connectors.connect('salesforce', {
  instanceUrl: 'https://yourorg.my.salesforce.com',
  consumerKey: process.env.SF_CONSUMER_KEY,
  consumerSecret: process.env.SF_CONSUMER_SECRET,
  refreshToken: process.env.SF_REFRESH_TOKEN
});

Synchroniser les contacts avec un filtre SOQL

// Sync only qualified leads from Salesforce
await tajo.connectors.sync('salesforce', {
  type: 'filtered',
  resources: ['leads'],
  filter: "SELECT Id, Email, FirstName, LastName, LeadScore__c FROM Lead WHERE Status = 'Qualified' AND Email != null",
  brevoListId: 16
});

// Check sync status
const status = await tajo.connectors.status('salesforce');
console.log(status);
// {
//   connected: true,
//   lastSync: '2024-01-15T10:30:00Z',
//   contactsSynced: 18400,
//   leadsSynced: 7200,
//   opportunitiesSynced: 3100
// }

Streaming en temps réel

// Subscribe to Salesforce Change Data Capture
await tajo.connectors.stream('salesforce', {
  channels: [
    '/data/ContactChangeEvent',
    '/data/LeadChangeEvent',
    '/data/OpportunityChangeEvent'
  ],
  handler: async (event) => {
    console.log(`Change detected: ${event.entity} ${event.changeType}`);
    // Automatically synced to Brevo by Tajo
  }
});

Limites de débit

Les limites de la REST API Salesforce dépendent de votre édition et du nombre de licences :

Limites supplémentaires :

• Limite d’API concurrentes : 25 requêtes longues
• Bulk API : 15 000 batches par 24 heures
• Streaming API : 2 000 événements par jour (peut être augmenté)
• Composite API : 25 sous-requêtes par requête composite

Dépannage

Problèmes courants

Mode débogage

Activez la journalisation détaillée :

connectors:
  salesforce:
    debug: true
    log_level: verbose
    log_api_calls: true

Tester la connexion

tajo connectors test salesforce
# ✓ OAuth token valid
# ✓ Contacts accessible
# ✓ Leads accessible
# ✓ Accounts accessible
# ✓ Opportunities accessible
# ✓ Bulk API enabled

Bonnes pratiques

1. Utilisez la Bulk API pour les synchronisations volumineuses, Passez à la Bulk API 2.0 pour les jeux de données de plus de 2 000 enregistrements
2. Implémentez le Change Data Capture, Utilisez CDC pour la synchronisation en temps réel au lieu du polling
3. Mappez uniquement les champs nécessaires, Réduisez l’usage API en ne synchronisant que les champs requis
4. Gérez le rafraîchissement du jeton, Implémentez une logique de rafraîchissement automatique du jeton OAuth
5. Utilisez les requêtes composites, Combinez les appels API liés pour réduire le nombre de requêtes
6. Testez d’abord en sandbox, Utilisez une org sandbox Salesforce avant le déploiement en production

Sécurité

• OAuth 2.0, Autorisation conforme aux standards de l’industrie avec plusieurs types d’octroi
• Restrictions d’IP, Salesforce prend en charge les plages d’IP de connexion et les paramètres d’IP de confiance
• TLS 1.2+, Toutes les communications API sont chiffrées avec TLS 1.2 minimum
• Sécurité au niveau des champs, Contrôle granulaire de l’accès aux champs par profil
• Gestion des sessions, Timeout de session et limites de sessions concurrentes configurables

Ressources associées

• Documentation REST API Salesforce
• Guide Bulk API 2.0 Salesforce
• Connecteur HubSpot
• Skill Customer Sync
• API Contacts Brevo