---
title: "Connecteur Optimizely"
description: "Guide complet d'intégration Optimizely pour synchroniser résultats d'expérimentation, feature flags et données d'audience avec Brevo via Tajo."
url: https://tajo.io/fr/docs/connectors/custom/optimizely/
markdown: https://tajo.io/fr/docs/connectors/custom/optimizely.md
lang: fr-FR
robots: noindex
---

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 Optimizely

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

| 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` |

Connectez Optimizely Feature Experimentation à Brevo via Tajo pour synchroniser les résultats d’expérimentation, cibler les campagnes par segments de feature flags et enrichir les automatisations marketing avec les données de tests A/B et les insights d’audience.

## Vue d’ensemble

| Propriété | Valeur |
| --- | --- |
| **Plateforme** | Optimizely |
| **Catégorie** | Expérimentation (Custom) |
| **Complexité d’installation** | Moyenne |
| **Intégration officielle** | Non |
| **Données synchronisées** | Expériences, audiences, événements, feature flags |
| **Méthode d’authentification** | Personal Access Token / OAuth 2.0 |

## Fonctionnalités

- **Synchronisation des expériences**, Poussez les attributions de variations de tests A/B vers les attributs de contact Brevo
- **Ciblage d’audience**, Utilisez les audiences Optimizely pour la segmentation de campagnes Brevo
- **Suivi des conversions**, Suivez les événements Optimizely et mappez-les vers le tracking d’événements Brevo
- **Synchronisation des feature flags**, Segmentez les contacts par feature flags activés
- **Reporting des résultats**, Synchronisez les résultats d’expérimentation pour des campagnes marketing post-analyse
- **Support multi-projets**, Connectez plusieurs projets Optimizely à une instance Tajo unique

## Prérequis

Avant de commencer, assurez-vous de disposer de :

1. Un compte Optimizely Feature Experimentation
2. Un Personal Access Token depuis [Optimizely App Settings](https://app.optimizely.com/v2/accountsettings/tokens)
3. Une SDK key pour votre environnement Optimizely
4. Un compte Brevo avec accès API
5. Un compte Tajo avec les permissions connecteur

## Authentification

### Personal Access Token

```bash
# Générez-le sur https://app.optimizely.com/v2/accountsettings/tokens
export OPTIMIZELY_ACCESS_TOKEN=your_personal_access_token
export OPTIMIZELY_SDK_KEY=your_sdk_key
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key
```

```javascript
// Toutes les requêtes de l'API REST utilisent l'auth par Bearer token
const headers = {
  'Authorization': `Bearer ${process.env.OPTIMIZELY_ACCESS_TOKEN}`,
  'Content-Type': 'application/json'
};
```

### Authentification SDK

```javascript
// Pour l'évaluation de feature flags, utilisez le SDK
const optimizelySDK = require('@optimizely/optimizely-sdk');

const optimizelyClient = optimizelySDK.createInstance({
  sdkKey: process.env.OPTIMIZELY_SDK_KEY,
  datafileOptions: {
    autoUpdate: true,
    updateInterval: 60000  // 1 minute
  }
});

await optimizelyClient.onReady();
```

## Configuration

### Configuration de base

```yaml
connectors:
  optimizely:
    enabled: true
    access_token: "${OPTIMIZELY_ACCESS_TOKEN}"
    sdk_key: "${OPTIMIZELY_SDK_KEY}"
    project_id: "12345678"

    sync:
      experiments: true
      audiences: true
      events: true
      feature_flags: true
      schedule: "0 */2 * * *"  # Toutes les 2 heures

    mapping:
      experiment_variation: EXPERIMENT_VARIATION
      feature_flags: ENABLED_FEATURES
      audience_segments: OPT_SEGMENTS
```

### Mappage des champs

```yaml
field_mapping:
  user_id: email
  experiment_key: EXPERIMENT_NAME
  variation_key: VARIATION_NAME
  feature_key: FEATURE_FLAG
  enabled: FEATURE_ENABLED
  audience_name: AUDIENCE_SEGMENT
  decision_timestamp: EXPERIMENT_DATE
```

## Endpoints API

| Endpoint | Méthode | Description |
| --- | --- | --- |
| `https://api.optimizely.com/v2/projects` | GET | Lister les projets |
| `https://api.optimizely.com/v2/experiments` | GET | Lister les expériences |
| `https://api.optimizely.com/v2/experiments/{id}` | GET | Obtenir les détails d’une expérience |
| `https://api.optimizely.com/v2/experiments/{id}/results` | GET | Obtenir les résultats d’une expérience |
| `https://api.optimizely.com/v2/features` | GET | Lister les feature flags |
| `https://api.optimizely.com/v2/features/{id}` | GET | Obtenir un feature flag |
| `https://api.optimizely.com/v2/audiences` | GET | Lister les audiences |
| `https://api.optimizely.com/v2/events` | GET | Lister les événements suivis |
| `https://logx.optimizely.com/v1/events` | POST | Tracker des événements (endpoint SDK) |

## Exemples de code

### Initialiser le connecteur

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

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

await tajo.connectors.connect('optimizely', {
  accessToken: process.env.OPTIMIZELY_ACCESS_TOKEN,
  sdkKey: process.env.OPTIMIZELY_SDK_KEY,
  projectId: '12345678'
});
```

### Synchroniser les décisions d’expérimentation vers Brevo

```javascript
// Tracker les décisions d'expérimentation et synchroniser vers Brevo
const optimizelyClient = optimizelySDK.createInstance({
  sdkKey: process.env.OPTIMIZELY_SDK_KEY
});

await optimizelyClient.onReady();

// Enregistrer un listener de notification de décision
optimizelyClient.notificationCenter.addNotificationListener(
  optimizelySDK.enums.NOTIFICATION_TYPES.DECISION,
  async (decisionObject) => {
    const { type, userId, attributes, decisionInfo } = decisionObject;

    if (type === 'feature' || type === 'ab-test') {
      const email = attributes.email;
      if (email) {
        await tajo.contacts.update(email, {
          attributes: {
            EXPERIMENT_NAME: decisionInfo.experimentKey || decisionInfo.featureKey,
            VARIATION_NAME: decisionInfo.variationKey,
            FEATURE_ENABLED: decisionInfo.featureEnabled || false,
            EXPERIMENT_DATE: new Date().toISOString()
          }
        });
      }
    }
  }
);
```

### Synchroniser les résultats d’expérimentation

```javascript
// Récupérer les résultats d'expérimentation et synchroniser les segments gagnants
const resultsResponse = await fetch(
  `https://api.optimizely.com/v2/experiments/${experimentId}/results`,
  {
    headers: {
      'Authorization': `Bearer ${process.env.OPTIMIZELY_ACCESS_TOKEN}`
    }
  }
);

const results = await resultsResponse.json();

// Traiter les variations et mettre à jour les segments de contact
for (const variation of results.metrics) {
  const isWinner = variation.is_improvement && variation.statistical_significance >= 0.95;

  if (isWinner) {
    // Créer un segment Brevo pour les utilisateurs de la variation gagnante
    console.log(`Winning variation: ${variation.variation_name}`);
  }
}
```

### Segmentation basée sur les feature flags

```javascript
// Évaluer les feature flags pour la segmentation utilisateur
async function syncFeatureFlags(userEmail, userId) {
  const features = ['new_checkout', 'loyalty_program', 'ai_recommendations'];
  const enabledFeatures = [];

  for (const feature of features) {
    const user = optimizelyClient.createUserContext(userId, {
      email: userEmail
    });
    const decision = user.decide(feature);

    if (decision.enabled) {
      enabledFeatures.push(feature);
    }
  }

  await tajo.contacts.update(userEmail, {
    attributes: {
      ENABLED_FEATURES: enabledFeatures.join(', '),
      FEATURE_FLAGS_SYNCED: new Date().toISOString()
    }
  });
}
```

## Limites de débit

| Endpoint | Limite | Notes |
| --- | --- | --- |
| REST API | 50 req/min | Par Personal Access Token |
| Results API | 10 req/min | Latence plus élevée, requêtes plus lourdes |
| SDK Event Dispatch | 10 000 événements/lot | Via le processeur d’événements du SDK |
| Datafile CDN | Illimité | Mis en cache avec mises à jour automatiques |

Latence de l'API de résultats

L’API Experiment Results traite de grands ensembles de données et peut prendre plus de 30 secondes à répondre. Utilisez un polling asynchrone ou un cache pour éviter de bloquer votre application.

## Dépannage

| Problème | Cause | Solution |
| --- | --- | --- |
| 401 Unauthorized | Token expiré/invalide | Régénérez le Personal Access Token |
| SDK pas prêt | Datafile non chargé | Attendez que la promesse `onReady()` se résolve |
| Aucune décision enregistrée | Notification non enregistrée | Enregistrez le listener avant de prendre des décisions |
| Feature flags périmés | Cache du datafile | Définissez `updateInterval` pour un auto-refresh |
| Résultats manquants | Expérimentation non démarrée | Vérifiez que le statut de l’expérimentation est « running » |

### Mode debug

```yaml
connectors:
  optimizely:
    debug: true
    log_level: verbose
    log_decisions: true
    log_events: true
```

## Bonnes pratiques

1. **Utilisez le SDK pour les décisions**, Utilisez le SDK pour l’évaluation de flags en temps réel, l’API REST pour la gestion
2. **Implémentez le batching d’événements**, Groupez les événements du SDK pour réduire la charge réseau
3. **Mettez en cache le datafile**, Activez l’auto-update avec des intervalles appropriés
4. **Synchronisez les variations gagnantes**, Après la conclusion d’une expérimentation, mettez à jour les segments de contacts
5. **Utilisez les attributs pour le ciblage**, Passez l’e-mail et les attributs utilisateur pour le matching d’audience
6. **Surveillez le statut des expérimentations**, Ne synchronisez que les données d’expérimentations en cours ou terminées

## Sécurité

- **Personal Access Tokens**, Authentification par Bearer token pour l’API REST
- **Isolation des SDK keys**, SDK keys séparées par environnement (dev, staging, prod)
- **Évaluation côté serveur**, Évaluez les feature flags côté serveur pour éviter l’exposition
- **Rotation des tokens**, Faites tourner les Personal Access Tokens périodiquement
- **Permissions minimales**, Utilisez des tokens en lecture seule lorsque l’accès en écriture n’est pas nécessaire
- **Transport chiffré**, TLS 1.2+ pour toutes les communications API et SDK

## Ressources associées

- [Connecteur PostHog](https://tajo.io/fr/docs/connectors/custom/posthog)
- [Connecteur Segment](https://tajo.io/fr/docs/connectors/custom/segment)
- [Skill de synchronisation client](https://tajo.io/fr/docs/skills/data-sync/customer-sync)
- [Documentation Optimizely Feature Experimentation](https://docs.developers.optimizely.com/feature-experimentation/docs)