Salesforce Connector

Salesforce Connector

Verbinde dein Salesforce-CRM über Tajo mit Brevo für eine Kontaktsynchronisierung auf Enterprise-Niveau, Lead-Management, Opportunity-Tracking und eine durch deine CRM-Daten gespeiste Marketingautomatisierung.

Überblick

Funktionen

• Bidirektionale Kontakt-/Lead-Synchronisierung - Synchronisiere Salesforce-Kontakte und -Leads mit Brevo-Kontaktlisten
• Opportunity-Tracking - Ordne Deal-Phasen und -Beträge für eine umsatzbasierte Segmentierung zu
• Account-Hierarchie - Synchronisiere Unternehmens-Accounts für Account-based Marketing in Brevo
• Zuordnung benutzerdefinierter Objekte - Ordne benutzerdefinierte Salesforce-Objekte Brevo-Attributen und -Events zu
• Kampagnenmitglieder-Synchronisierung - Synchronisiere Salesforce-Kampagnenmitglieder mit Brevo-Listen
• Aktivitäts-Tracking - Synchronisiere Aufgaben, Events und E-Mail-Aktivitäten für Engagement-Scoring
• Echtzeit-Streaming - Nutze die Salesforce Streaming API für sofortige Datenaktualisierungen
• SOQL-Abfrageunterstützung - Filtere synchronisierte Daten mit benutzerdefinierten SOQL-Abfragen

Voraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

1. Eine Salesforce-Organisation (jede Edition mit API-Zugriff)
2. Eine in Salesforce Setup konfigurierte Connected App
3. API-Zugriff für dein Salesforce-Nutzer:innen-Profil aktiviert
4. Ein Brevo-Konto mit API-Zugriff
5. Ein Tajo-Konto

Authentifizierung

OAuth 2.0 Web-Server-Flow (Empfohlen)

Am besten geeignet für produktive Integrationen mit Autorisierung durch Nutzer:innen.

# 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}"

Username-Password-Flow

Für Server-zu-Server-Integrationen ohne Interaktion durch Nutzer:innen.

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}"

Konfiguration

Grundeinrichtung

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

Feldzuordnung

Ordne Salesforce-Felder Brevo-Kontaktattributen zu:

Zuordnung benutzerdefinierter Felder

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

API-Endpunkte

REST-API-Ressourcen

Bulk API

Streaming API

Events

Datensatz-Events (Change Data Capture)

Platform Events

Code-Beispiele

Connector initialisieren

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

Kontakte mit SOQL-Filter synchronisieren

// 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
// }

Echtzeit-Streaming

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

Ratenbegrenzungen

Die Grenzen der Salesforce REST API hängen von deiner Edition und der Anzahl der Lizenzen ab:

Weitere Begrenzungen:

• Limit für gleichzeitige API-Aufrufe: 25 lang laufende Anfragen
• Bulk API: 15.000 Batches pro 24 Stunden
• Streaming API: 2.000 Events pro Tag (kann erhöht werden)
• Composite API: 25 Subrequests pro Composite-Anfrage

Fehlerbehebung

Häufige Probleme

Debug-Modus

Ausführliches Logging aktivieren:

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

Verbindung testen

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

Best Practices

1. Bulk API für große Synchronisierungen nutzen - Wechsle bei Datensätzen über 2.000 Einträgen zur Bulk API 2.0
2. Change Data Capture implementieren - Verwende CDC für Echtzeit-Synchronisierung statt Polling
3. Nur benötigte Felder zuordnen - Reduziere die API-Nutzung, indem du nur erforderliche Felder synchronisierst
4. Token-Refresh handhaben - Implementiere eine automatische OAuth-Token-Refresh-Logik
5. Composite-Requests verwenden - Kombiniere zusammengehörige API-Aufrufe, um die Anzahl der Anfragen zu reduzieren
6. Zuerst in der Sandbox testen - Nutze eine Salesforce-Sandbox-Organisation vor dem produktiven Rollout

Sicherheit

• OAuth 2.0 - Branchenstandard-Autorisierung mit mehreren Grant-Typen
• IP-Beschränkungen - Salesforce unterstützt Login-IP-Bereiche und Einstellungen für vertrauenswürdige IPs
• TLS 1.2+ - Die gesamte API-Kommunikation wird mit mindestens TLS 1.2 verschlüsselt
• Feldbasierte Sicherheit - Granulare Feldzugriffskontrolle pro Profil
• Session-Management - Konfigurierbare Session-Timeouts und Limits für gleichzeitige Sitzungen

Verwandte Ressourcen

• Salesforce REST API-Dokumentation
• Salesforce Bulk API 2.0 Guide
• HubSpot Connector
• Customer-Sync-Skill
• Brevo Contacts API