Rapports sur les tests

Il existe deux manières principales de créer des rapports sur les tests :

• Rapports directs sur les tests : interrogez la experiment ressource pour obtenir des métriques. Cette option fournit des métriques pour les bras de contrôle et de traitement dans une seule réponse, ainsi que des données de comparaison statistiques telles que l'augmentation et les valeurs p. Il s'agit du seul moyen de créer des rapports sur les tests au sein d'une même campagne.
• Rapports sur les campagnes : interrogez la ressource campaign pour obtenir des métriques, en utilisant campaign.experiment_type pour faire la distinction entre les campagnes de base et les campagnes tests. Cette option n'est disponible que pour les tests qui utilisent des campagnes de contrôle et de traitement distinctes, comme les tests gérés par le système.

Ce guide se concentre principalement sur les rapports directs sur les tests, qui sont compatibles avec tous les types de tests qui prennent en charge les rapports.

Rapports directs sur les tests

Vous pouvez interroger directement la ressource experiment pour récupérer les métriques de performances et les comparaisons statistiques entre vos bras de contrôle et de traitement.

Métriques et pertinence statistique

Pour les métriques de base telles que les clics, les impressions, le coût, les conversions et la valeur de conversion, la ressource experiment fournit à la fois des métriques de traitement (par exemple, metrics.clicks) et des métriques de contrôle (par exemple, metrics.control_clicks) sur la même ligne.

Elle fournit également des champs pour vous aider à évaluer la pertinence statistique de toute différence entre les bras :

• metrics.*_p_value: probabilité que les résultats observés se produisent si le test n'avait aucun effet réel sur la métrique. Une valeur p plus faible indique une pertinence statistique plus élevée.
• metrics.*_point_estimate: augmentation estimée en pourcentage (positive ou négative) de la métrique donnée pour le groupe de traitement par rapport au groupe de contrôle. Avec margin_of_error, ils décrivent un intervalle de confiance avec un niveau de confiance prescrit pour la différence estimée. La quantité estimée est (traitement / contrôle - 1). L'estimation ponctuelle est le centre de l'intervalle de confiance.
• metrics.*_margin_of_error: rayon de l'intervalle de confiance, centré sur point_estimate. Il est calculé pour un niveau de confiance prescrit, qui dépend du type de test.

Les champs de métriques de base suivants sont compatibles avec la ressource experiment, y compris une valeur de groupe de traitement, une valeur de groupe de contrôle et les champs de statistiques listés précédemment :

• clicks
• impressions
• cost_micros
• conversions
• cost_per_conversion
• conversion_value
• conversion_value_per_cost

Pour les conversions, en particulier, les champs statistiques sont disponibles via les champs absolute_change suivants, plutôt que sous forme de valeurs relatives :

• metrics.conversions_absolute_change_p_value: valeur p pour l'hypothèse nulle selon laquelle le test n'a aucun effet sur la modification absolue des conversions. Plage de 0 à 1.
• metrics.conversions_absolute_change_point_estimate: estimation ponctuelle lors de l'estimation de l'effet du test sur la modification absolue des conversions.
• metrics.conversions_absolute_change_margin_of_error: marge d'erreur lors de l'estimation de l'effet du test sur la modification absolue des conversions.

Pour obtenir de l'aide sur la création de requêtes valides pour la ressource experiment, utilisez l' outil de création de requêtes Google Ads.

Exemple de requête

La requête GAQL suivante récupère les métriques clés d'un test :

SELECT
  experiment.experiment_id,
  experiment.name,
  experiment.type,
  metrics.clicks,
  metrics.control_clicks,
  metrics.clicks_point_estimate,
  metrics.clicks_margin_of_error,
  metrics.clicks_p_value,
  metrics.conversions,
  metrics.control_conversions,
  metrics.conversions_absolute_change_point_estimate,
  metrics.conversions_absolute_change_margin_of_error,
  metrics.conversions_absolute_change_p_value
FROM experiment
WHERE experiment.experiment_id = EXPERIMENT_ID

Interpréter les résultats

Vous pouvez utiliser les champs de valeur p, d'estimation ponctuelle et de marge d'erreur pour déterminer si votre test a généré des résultats statistiquement pertinents. Par exemple, si conversions_absolute_change_p_value est inférieur au seuil que vous avez choisi (par exemple, 0,05 pour une confiance de 95 %) et que conversions_absolute_change_point_estimate - conversions_absolute_change_margin_of_error est supérieur à zéro, cela indique que le groupe de traitement est nettement plus performant que le groupe de contrôle en termes de conversions.

Voici un extrait de code Python qui montre comment évaluer les résultats en fonction de la valeur p et des estimations d'augmentation :

Java

private void evaluateExperiment(
    GoogleAdsClient googleAdsClient, long customerId, GoogleAdsRow row) {
  Metrics metrics = row.getMetrics();
  String experimentResourceName = row.getExperiment().getResourceName();

  // 1. Evaluate conversion success as a primary success signal if available.
  // - Point Estimate: Represents the estimated average lift or difference in conversions.
  // - Margin of Error: Outlines the confidence interval bounds. Note that the margin_of_error
  //   provided by the API is calculated for a preset confidence level which is set based on the
  //   experiment type.
  // - Lower Bound: (Point Estimate - Margin of Error). If this value is above 0,
  //   we have statistical significance that performance has improved.
  double convPValue = metrics.getConversionsAbsoluteChangePValue();
  double convLift = metrics.getConversionsAbsoluteChangePointEstimate();
  double convError = metrics.getConversionsAbsoluteChangeMarginOfError();
  double convLowerBound = convLift - convError;

  if (convPValue <= P_VALUE_THRESHOLD) {
    if (convLowerBound > 0) {
      System.out.printf(
          "Significant Success: Conversions increased. Even at the lower bound, the lift is %.2f."
              + " Promoting changes.%n",
          convLowerBound);
      promoteExperiment(googleAdsClient, customerId, experimentResourceName);
      return;
    } else if ((convLift + convError) < 0) {
      System.out.printf(
          "Significant Decline: Even the upper bound (%.2f) is below zero. Ending experiment.%n",
          convLift + convError);
      endExperiment(googleAdsClient, customerId, experimentResourceName);
      return;
    }
  }

  // 2. Fall back to evaluating click metrics if conversions are inconclusive.
  double clickPValue = metrics.getClicksPValue();
  double clickLift = metrics.getClicksPointEstimate();
  double clickError = metrics.getClicksMarginOfError();
  double clickLowerBound = clickLift - clickError;

  if (clickPValue <= P_VALUE_THRESHOLD && clickLowerBound > 0) {
    System.out.printf("Click volume is significantly up (+%.1f%%).%n", clickLift * 100);

    // Graduation is only supported for separate campaign experiments, not
    // intra-campaign experiments where there is no separate treatment campaign.
    ExperimentType experimentType = row.getExperiment().getType();
    if (experimentType != ExperimentType.ADOPT_BROAD_MATCH_KEYWORDS
        && experimentType != ExperimentType.ADOPT_AI_MAX) {
      System.out.println("Graduating treatment campaign for further manual analysis.");
      graduateExperiment(googleAdsClient, customerId, experimentResourceName);
    } else {
      System.out.println(
          "Intra-campaign trial detected: graduation is not supported. Continuing to run the"
              + " experiment to gather more conversion data.");
    }
  } else {
    // 3. Print status if no action was taken.
    System.out.printf(
        "Inconclusive: No significant lift in Conversions (p=%.2f) or Clicks (p=%.2f). Current"
            + " estimated lift: %.2f +/- %.2f. Allowing the experiment to continue running.%n",
        convPValue, clickPValue, convLift, convError);
  }
}
EvaluateAndUpdateExperiment.java
      

C#

private static void EvaluateExperiment(GoogleAdsClient client, long customerId, GoogleAdsRow row)
{
    // This function evaluates performance metrics and immediately takes action
    // to update the experiment's status (promote, end, or graduate) if
    // statistical significance thresholds are met.
    var metrics = row.Metrics;
    string experimentResourceName = row.Experiment.ResourceName;

    bool hasConvMetrics = metrics.HasConversionsAbsoluteChangePValue
        && metrics.HasConversionsAbsoluteChangePointEstimate
        && metrics.HasConversionsAbsoluteChangeMarginOfError;

    bool hasClickMetrics = metrics.HasClicksPValue
        && metrics.HasClicksPointEstimate
        && metrics.HasClicksMarginOfError;

    // 1. Evaluate conversion success as a primary success signal if available.
    // - Point Estimate: Represents the estimated average lift or difference in conversions.
    // - Margin of Error: Outlines the confidence interval bounds. Note that the margin_of_error
    //   provided by the API is calculated for a preset confidence level which is set based on
    //   the experiment type.
    // - Lower Bound: (Point Estimate - Margin of Error). If this value is above 0,
    //   we have statistical significance that performance has improved.
    if (hasConvMetrics)
    {
        double convPValue = metrics.ConversionsAbsoluteChangePValue;
        double convLift = metrics.ConversionsAbsoluteChangePointEstimate;
        double convError = metrics.ConversionsAbsoluteChangeMarginOfError;
        double convLowerBound = convLift - convError;

        if (convPValue <= P_VALUE_THRESHOLD)
        {
            if (convLowerBound > 0)
            {
                Console.WriteLine(
                    $"Significant Success: Conversions increased. Even at the lower" +
                    $" bound, the lift is {convLowerBound:F2}. Promoting changes.");
                PromoteExperiment(client, customerId, experimentResourceName);
                return;
            }
            else if ((convLift + convError) < 0)
            {
                Console.WriteLine(
                    $"Significant Decline: Even the upper bound ({convLift + convError:F2}) " +
                    $"is below zero. Ending experiment.");
                EndExperiment(client, customerId, experimentResourceName);
                return;
            }
        }
    }

    // 2. Evaluate click volume as a secondary signal.
    // This is helpful as an early indicator or for lower-volume accounts.
    if (hasClickMetrics)
    {
        double clickPValue = metrics.ClicksPValue;
        double clickLift = metrics.ClicksPointEstimate;
        double clickError = metrics.ClicksMarginOfError;
        double clickLowerBound = clickLift - clickError;

        if (clickPValue <= P_VALUE_THRESHOLD && clickLowerBound > 0)
        {
            // We have a directional winner: high confidence in more traffic,
            // but not enough data to confirm conversion impact yet.
            Console.WriteLine(
                $"Click volume is significantly up (+{clickLift * 100:F1}%).");

            // Graduation is only supported for separate campaign experiments, not
            // intra-campaign experiments where there is no separate treatment campaign.
            if (row.Experiment.Type != ExperimentType.AdoptBroadMatchKeywords
                && row.Experiment.Type != ExperimentType.AdoptAiMax)
            {
                Console.WriteLine("Graduating treatment campaign for further manual analysis.");
                GraduateExperiment(client, customerId, experimentResourceName);
            }
            else
            {
                Console.WriteLine(
                    "Intra-campaign trial detected: graduation is not supported. " +
                    "Continuing to run the experiment to gather more conversion data.");
            }
            return;
        }
    }

    // 3. Print status if no action was taken.
    if (hasConvMetrics || hasClickMetrics)
    {
        string convStatus = hasConvMetrics
            ? $"Conversions (p={metrics.ConversionsAbsoluteChangePValue:F2}, " +
              $"lift={metrics.ConversionsAbsoluteChangePointEstimate:F2} +/- " +
              $"{metrics.ConversionsAbsoluteChangeMarginOfError:F2})"
            : "Conversions (not populated)";

        string clickStatus = hasClickMetrics
            ? $"Clicks (p={metrics.ClicksPValue:F2}, " +
              $"lift={metrics.ClicksPointEstimate:F2} +/- " +
              $"{metrics.ClicksMarginOfError:F2})"
            : "Clicks (not populated)";

        Console.WriteLine(
            $"Inconclusive: No significant action taken. {convStatus}, {clickStatus}. " +
            "Allowing the experiment to continue running.");
    }
    else
    {
        Console.WriteLine(
            "Conversion and click performance metrics are not yet populated. " +
            "Allowing the experiment to continue running.");
    }
}
EvaluateAndUpdateExperiment.cs
      

PHP

This example is not yet available in PHP; you can take a look at the other languages.
    

Python

def evaluate_experiment(
    client: GoogleAdsClient, customer_id: str, row: GoogleAdsRow
) -> None:
    """Evaluates the performance of the experiment and updates it accordingly
    (for example, promotes, ends, or graduates).

    Checks conversion and click metrics against statistical significance thresholds
    to determine the appropriate action to take on the experiment.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        row: a GoogleAdsRow containing the experiment and metrics.
    """
    # This function evaluates performance metrics and immediately takes action
    # to update the experiment's status (promote, end, or graduate) if
    # statistical significance thresholds are met.
    metrics = row.metrics
    experiment_resource_name = row.experiment.resource_name

    has_conv_metrics = (
        "conversions_absolute_change_p_value" in metrics
        and "conversions_absolute_change_point_estimate" in metrics
        and "conversions_absolute_change_margin_of_error" in metrics
    )
    has_click_metrics = (
        "clicks_p_value" in metrics
        and "clicks_point_estimate" in metrics
        and "clicks_margin_of_error" in metrics
    )

    # 1. Evaluate conversion success as a primary success signal if available.
    # - Point Estimate: Represents the estimated average lift or difference in conversions.
    # - Margin of Error: Outlines the confidence interval bounds. Note that the margin_of_error provided by the API is calculated for a preset confidence level which is set based on the experiment type.
    # - Lower Bound: (Point Estimate - Margin of Error). If this value is above 0,
    #   we have statistical significance that performance has improved.
    if has_conv_metrics:
        conv_p_value = metrics.conversions_absolute_change_p_value
        conv_lift = metrics.conversions_absolute_change_point_estimate
        conv_error = metrics.conversions_absolute_change_margin_of_error
        conv_lower_bound = conv_lift - conv_error

        if conv_p_value <= P_VALUE_THRESHOLD:
            if conv_lower_bound > 0:
                print(
                    "Significant Success: Conversions increased. Even at the lower"
                    f" bound, the lift is {conv_lower_bound:.2f}. Promoting"
                    " changes."
                )
                promote_experiment(
                    client, customer_id, experiment_resource_name
                )
                return
            elif (conv_lift + conv_error) < 0:
                print(
                    "Significant Decline: Even the upper bound"
                    f" ({conv_lift + conv_error:.2f}) is below zero. Ending"
                    " experiment."
                )
                end_experiment(client, customer_id, experiment_resource_name)
                return

        # 2. Evaluate click volume as a secondary signal.
        # This is helpful as an early indicator or for lower-volume accounts.
        click_p_value = metrics.clicks_p_value
        click_lift = metrics.clicks_point_estimate
        click_error = metrics.clicks_margin_of_error
        click_lower_bound = click_lift - click_error

        if click_p_value <= P_VALUE_THRESHOLD and click_lower_bound > 0:
            # We have a directional winner: high confidence in more traffic,
            # but not enough data to confirm conversion impact yet.
            print(f"Click volume is significantly up (+{click_lift*100:.1f}%).")

            # Graduation is only supported for separate campaign experiments, not
            # intra-campaign experiments where there is no separate treatment campaign.
            experiment_type_name = row.experiment.type_.name
            if (
                experiment_type_name != "ADOPT_BROAD_MATCH_KEYWORDS"
                and experiment_type_name != "ADOPT_AI_MAX"
            ):
                print(
                    "Graduating treatment campaign for further manual analysis."
                )
                graduate_experiment(
                    client, customer_id, experiment_resource_name
                )
            else:
                print(
                    "Intra-campaign trial detected: graduation is not supported. "
                    "Continuing to run the experiment to gather more conversion data."
                )
            return

    # 3. Print status if no action was taken.
    if has_conv_metrics or has_click_metrics:
        conv_status = (
            f"Conversions (p={metrics.conversions_absolute_change_p_value:.2f}, "
            f"lift={metrics.conversions_absolute_change_point_estimate:.2f} +/- "
            f"{metrics.conversions_absolute_change_margin_of_error:.2f})"
            if has_conv_metrics
            else "Conversions (not populated)"
        )
        click_status = (
            f"Clicks (p={metrics.clicks_p_value:.2f}, "
            f"lift={metrics.clicks_point_estimate:.2f} +/- "
            f"{metrics.clicks_margin_of_error:.2f})"
            if has_click_metrics
            else "Clicks (not populated)"
        )
        print(
            f"Inconclusive: No significant action taken. {conv_status}, {click_status}."
            " Allowing the experiment to continue running."
        )
    else:
        print(
            "Conversion and click performance metrics are not yet populated. "
            "Allowing the experiment to continue running."
        )
evaluate_and_update_experiment.py
      

Ruby

This example is not yet available in Ruby; you can take a look at the other languages.
    

Perl

This example is not yet available in Perl; you can take a look at the other languages.
    

curl

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni ici pour cette étape, vous pouvez y parvenir à l'aide d'une requête REST manuelle.

Consultez la documentation de l'interface REST de l'API Google Ads et les pages de référence spécifiques à la méthode. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages de champs JSON
• Consultez la référence de l'API REST pour le service et la méthode spécifiques.

Avantages par rapport aux rapports sur les campagnes

Les rapports directs sur les tests offrent plusieurs avantages par rapport à l'interrogation des rapports sur les campagnes séparément :

1. Métriques centralisées : récupérez les métriques de contrôle et de traitement sur une seule ligne.
2. Données de confiance statistiques : fournit des valeurs p, des estimations ponctuelles et des marges d'erreur calculées.
3. Efficacité : élimine le besoin de joindre ou de comparer manuellement les résultats de plusieurs rapports.
4. Compatibilité avec les campagnes : il s'agit du seul moyen de comparer le contrôle et le traitement pour les tests au sein d'une même campagne, où le trafic est réparti au sein d'une seule campagne.

Rapports sur les campagnes

Pour les tests qui créent des campagnes de traitement distinctes (par exemple, SEARCH_CUSTOM), vous pouvez interroger la ressource campaign et utiliser campaign.experiment_type pour identifier les campagnes BASE (contrôle) et EXPERIMENT (traitement). Cette approche est utile si vous devez segmenter les métriques à un niveau plus précis (par exemple, par groupe d'annonces ou par mot clé) ou afficher des métadonnées de campagne non disponibles dans la ressource experiment. Toutefois, vous devez effectuer manuellement des comparaisons de performances et des calculs statistiques.

Vous ne pouvez pas utiliser les rapports au niveau de la campagne pour comparer les bras des tests au sein d'une même campagne, car la répartition du trafic s'effectue en interne dans une seule campagne. L'interrogation de campaign pour un test au sein d'une même campagne ne renvoie que des totaux agrégés.

Rapports sur le brand lift

Vous pouvez créer des rapports sur les études Brand Lift dans l'API Google Ads à l'aide de ressources de mesure du brand lift dédiées.

Remarque : Le numéro client que vous souhaitez interroger doit être autorisé par Global Product Solutions (GPS). Contactez votre représentant Google ou votre contact GPS avant de commencer votre intégration.

Ressources Brand Lift et vues de répartition

Interrogez la LiftMeasurementFlight ressource pour récupérer les résultats de l'étude Brand Lift au niveau du vol, y compris les plages de dates du vol (start_date et end_date) dans le fuseau horaire du client.

Pour analyser les métriques Brand Lift sur différentes dimensions de segment, interrogez les ressources de répartition correspondantes :

• LiftMeasurementCampaign: répartition par campagne.
• LiftMeasurementAgeRange: répartition par tranche d'âge.
• LiftMeasurementDevice: répartition par appareil.
• LiftMeasurementGender: répartition par genre.
• LiftMeasurementVideo: répartition par asset vidéo.

L'enum BrandLiftMeasurementType spécifie le type de mesure de l'étude, tel que la notoriété de la marque ou le souvenir publicitaire.

Exemples de requêtes Brand Lift

Étant donné que les métadonnées de vol et les statistiques d'augmentation résident sur des ressources distinctes, l'interrogation des détails du vol et des statistiques de performances nécessite des requêtes GAQL distinctes.

Requête de détails du vol

Pour récupérer les métadonnées d'un vol Brand Lift, telles que son état, son type de mesure et ses dates planifiées, interrogez la LiftMeasurementFlight ressource :

SELECT
  lift_measurement_flight.lift_measurement_config_id,
  lift_measurement_flight.lift_measurement_flight_id,
  lift_measurement_flight.name,
  lift_measurement_flight.status,
  lift_measurement_flight.lift_type,
  lift_measurement_flight.start_date,
  lift_measurement_flight.end_date
FROM lift_measurement_flight
WHERE lift_measurement_flight.lift_measurement_config_id = CONFIG_ID

Requête de statistiques

Pour récupérer les métriques Brand Lift, interrogez la ressource de répartition appropriée (ou la configuration d'étude globale sur LiftMeasurementConfig). Par exemple, la requête suivante récupère les métriques Brand Lift réparties par campagne à partir de LiftMeasurementCampaign :

SELECT
  lift_measurement_campaign.lift_measurement_config_id,
  lift_measurement_campaign.campaign,
  metrics.absolute_brand_lift,
  metrics.relative_brand_lift
FROM lift_measurement_campaign
WHERE lift_measurement_campaign.lift_measurement_config_id = CONFIG_ID

Rapports sur le conversion lift

Vous pouvez mesurer l'impact incrémental de vos annonces sur les conversions à l'aide des rapports sur le conversion lift dans l'API Google Ads.

Remarque : Le numéro client que vous souhaitez interroger doit être autorisé par Global Product Solutions (GPS). Contactez votre représentant Google ou votre contact GPS avant de commencer votre intégration. De plus, l'accès au niveau du compte administrateur (CM) pour le conversion lift est actuellement en cours de développement.

Configuration et métriques du conversion lift

Interrogez la LiftMeasurementConfig ressource pour récupérer les configurations d'étude et les données sur les performances du conversion lift.

La ressource fournit des métriques de conversion lift pour évaluer les performances incrémentales :

• metrics.conversion_lift_baseline_conversions: conversions de référence pour l'étude.
• metrics.conversion_lift_exposed_conversions: conversions observées dans le groupe exposé.
• metrics.incremental_conversions: conversions incrémentales attribuées aux annonces.
• metrics.cost_per_incremental_conversion: coût par conversion incrémentale.
• metrics.relative_conversion_lift: augmentation relative des conversions.
• metrics.conversion_lift_baseline_conversion_value: valeur de conversion de référence.
• metrics.conversion_lift_exposed_conversion_value: valeur de conversion dans le groupe exposé.
• metrics.incremental_conversion_value: valeur de conversion incrémentale attribuée aux annonces.
• metrics.relative_conversion_value_lift: augmentation relative de la valeur de conversion.

Les rapports sur le conversion lift permettent également de segmenter par actions de conversion et de récupérer les détails des campagnes associées, les détails des tests et les objectifs de conversion.

Exemple de requête de conversion lift

La requête GAQL suivante récupère les configurations de conversion lift et les métriques de performances clés :

SELECT
  lift_measurement_config.lift_measurement_config_id,
  segments.conversion_lift_start_date,
  segments.conversion_lift_end_date,
  segments.conversion_lift_included_conversion_action_types,
  metrics.conversion_lift_baseline_conversions,
  metrics.conversion_lift_exposed_conversions,
  metrics.incremental_conversions,
  metrics.cost_per_incremental_conversion,
  metrics.relative_conversion_lift,
  metrics.incremental_conversion_value,
  metrics.relative_conversion_value_lift
FROM lift_measurement_config
WHERE segments.conversion_lift_start_date = START_DATE
  AND segments.conversion_lift_end_date = END_DATE
  AND lift_measurement_config.lift_measurement_config_id = CONFIG_ID

Bonnes pratiques

• Sélectionnez un niveau de confiance approprié : la définition d'un seuil de valeur p inférieur peut fournir des conseils directionnels plus rapidement, en particulier avec des budgets ou des volumes de conversion plus faibles. Une confiance de 95 % (valeur p <= 0,05) est considérée comme la norme académique et peut être préférable pour obtenir des résultats plus précis sur une période plus longue.
• Exécutez les tests suffisamment longtemps : exécutez les tests pendant au moins quatre semaines pour tenir compte des cycles de performances hebdomadaires, des délais de conversion et des périodes d'apprentissage.
• Laissez le temps de la montée en puissance : pour les campagnes qui utilisent des enchères automatiques ou qui testent de nouvelles fonctionnalités, ignorez les données des une à deux premières semaines pour laisser le temps aux modèles d'enchères et aux niveaux de trafic de se recalibrer sur la répartition.
• Utilisez des répartitions à 50/50 : une répartition du trafic à 50/50 est généralement le moyen le plus rapide d' obtenir des résultats statistiquement pertinents.
• Planifiez à l'avance : définissez la date de début de votre test trois à sept jours à l' avance pour laisser le temps aux processus d'examen et d'approbation des annonces.
• Vous ne pouvez exécuter qu'un seul test par campagne à la fois.