Pour configurer des annonces dynamiques du Réseau de Recherche avec l'API Google Ads, procédez comme suit:
- Créez une campagne et spécifiez son domaine.
- Créez un groupe d'annonces pour les fonctionnalités liées aux annonces dynamiques du Réseau de Recherche.
- Créez une ou plusieurs annonces dynamiques du Réseau de Recherche.
- Spécifiez un ou plusieurs critères pour diffuser les annonces dynamiques du Réseau de Recherche dans la campagne.
Créer la campagne
Pour indiquer à Google Ads que vous allez utiliser des annonces dynamiques du Réseau de Recherche dans votre campagne, vous devez d'abord créer un Campaign avec le champ advertising_channel_type défini sur AdvertisingChannelType.SEARCH. Indiquez également un domaine sur lequel les annonces dynamiques du Réseau de Recherche seront exécutées. Pour ce faire, définissez le champ dynamic_search_ads_setting de Campaign à l'aide d'un DynamicSearchAdsSetting.
L'exemple suivant permet de créer une campagne d'ADR.
Java
private static String addCampaign(
GoogleAdsClient googleAdsClient, long customerId, String budgetResourceName) {
// Creates the campaign.
Campaign campaign =
Campaign.newBuilder()
.setName("Interplanetary Cruise #" + getPrintableDateTime())
.setAdvertisingChannelType(AdvertisingChannelType.SEARCH)
.setStatus(CampaignStatus.PAUSED)
.setManualCpc(ManualCpc.newBuilder().build())
.setCampaignBudget(budgetResourceName)
// Enables the campaign for DSAs.
.setDynamicSearchAdsSetting(
DynamicSearchAdsSetting.newBuilder()
.setDomainName("example.com")
.setLanguageCode("en")
.build())
.setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd"))
.setEndDate(new DateTime().plusDays(30).toString("yyyyMMdd"))
.build();
// Creates the operation.
CampaignOperation operation = CampaignOperation.newBuilder().setCreate(campaign).build();
// Creates the campaign service client.
try (CampaignServiceClient campaignServiceClient =
googleAdsClient.getLatestVersion().createCampaignServiceClient()) {
// Adds the campaign.
MutateCampaignsResponse response =
campaignServiceClient.mutateCampaigns(
Long.toString(customerId), ImmutableList.of(operation));
String campaignResourceName = response.getResults(0).getResourceName();
// Displays the results.
System.out.printf("Added campaign with resource name '%s'.%n", campaignResourceName);
return campaignResourceName;
}
}
C#
private static string AddCampaign(GoogleAdsClient client, long customerId,
string budgetResourceName)
{
// Get the CampaignService.
CampaignServiceClient campaignService = client.GetService(Services.V16.CampaignService);
// Create the campaign.
Campaign campaign = new Campaign()
{
Name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(),
AdvertisingChannelType = AdvertisingChannelType.Search,
Status = CampaignStatus.Paused,
ManualCpc = new ManualCpc(),
CampaignBudget = budgetResourceName,
// Enable the campaign for DSAs.
DynamicSearchAdsSetting = new DynamicSearchAdsSetting()
{
DomainName = "example.com",
LanguageCode = "en"
},
StartDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd"),
EndDate = DateTime.Now.AddDays(30).ToString("yyyyMMdd")
};
// Create the operation.
CampaignOperation operation = new CampaignOperation()
{
Create = campaign
};
// Add the campaign.
MutateCampaignsResponse response =
campaignService.MutateCampaigns(customerId.ToString(),
new CampaignOperation[] { operation });
// Displays the result.
string campaignResourceName = response.Results[0].ResourceName;
Console.WriteLine($"Added campaign with resource name '{campaignResourceName}'.");
return campaignResourceName;
}
PHP
private static function createCampaign(
GoogleAdsClient $googleAdsClient,
int $customerId,
string $campaignBudgetResourceName
) {
$campaign = new Campaign([
'name' => 'Interplanetary Cruise #' . Helper::getPrintableDatetime(),
'advertising_channel_type' => AdvertisingChannelType::SEARCH,
'status' => CampaignStatus::PAUSED,
'manual_cpc' => new ManualCpc(),
'campaign_budget' => $campaignBudgetResourceName,
// Enables the campaign for DSAs.
'dynamic_search_ads_setting' => new DynamicSearchAdsSetting([
'domain_name' => 'example.com',
'language_code' => 'en'
]),
// Optional: Sets the start and end dates for the campaign, beginning one day from
// now and ending a month from now.
'start_date' => date('Ymd', strtotime('+1 day')),
'end_date' => date('Ymd', strtotime('+1 month'))
]);
// Creates a campaign operation.
$campaignOperation = new CampaignOperation();
$campaignOperation->setCreate($campaign);
// Issues a mutate request to add campaigns.
$campaignServiceClient = $googleAdsClient->getCampaignServiceClient();
/** @var MutateCampaignsResponse $campaignResponse */
$campaignResponse = $campaignServiceClient->mutateCampaigns(
MutateCampaignsRequest::build($customerId, [$campaignOperation])
);
$campaignResourceName = $campaignResponse->getResults()[0]->getResourceName();
printf("Added campaign named '%s'.%s", $campaignResourceName, PHP_EOL);
return $campaignResourceName;
}
Python
def create_campaign(client, customer_id, budget_resource_name):
"""Creates a Dynamic Search Ad Campaign under the given customer ID.
Args:
client: an initialized GoogleAdsClient instance.
customer_id: a client customer ID str.
budget_resource_name: a resource_name str for a Budget
Returns:
A resource_name str for the newly created Campaign.
"""
# Retrieve a new campaign operation object.
campaign_operation = client.get_type("CampaignOperation")
campaign = campaign_operation.create
campaign.name = f"Interplanetary Cruise #{uuid4()}"
campaign.advertising_channel_type = (
client.enums.AdvertisingChannelTypeEnum.SEARCH
)
# Recommendation: Set the campaign to PAUSED when creating it to prevent the
# ads from immediately serving. Set to ENABLED once you've added targeting
# and the ads are ready to serve.
campaign.status = client.enums.CampaignStatusEnum.PAUSED
campaign.manual_cpc.enhanced_cpc_enabled = True
campaign.campaign_budget = budget_resource_name
# Required: Enable the campaign for DSAs by setting the campaign's dynamic
# search ads setting domain name and language.
campaign.dynamic_search_ads_setting.domain_name = "example.com"
campaign.dynamic_search_ads_setting.language_code = "en"
# Optional: Sets the start and end dates for the campaign, beginning one day
# from now and ending a month from now.
campaign.start_date = (datetime.now() + timedelta(days=1)).strftime(
"%Y%m%d"
)
campaign.end_date = (datetime.now() + timedelta(days=30)).strftime("%Y%m%d")
# Retrieve the campaign service.
campaign_service = client.get_service("CampaignService")
# Issues a mutate request to add campaign.
response = campaign_service.mutate_campaigns(
customer_id=customer_id, operations=[campaign_operation]
)
resource_name = response.results[0].resource_name
print(f'Created campaign with resource_name: "{resource_name}"')
Ruby
def create_campaign(client, customer_id, budget_resource_name)
campaign = client.resource.campaign do |c|
c.name = "Interplanetary Cruise #{(Time.now.to_f * 1000).to_i}"
c.advertising_channel_type = :SEARCH
c.status = :PAUSED
c.manual_cpc = client.resource.manual_cpc
c.campaign_budget = budget_resource_name
c.dynamic_search_ads_setting = client.resource.dynamic_search_ads_setting do |s|
s.domain_name = "example.com"
s.language_code = "en"
end
c.start_date = DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d')
c.end_date = DateTime.parse(Date.today.next_year.to_s).strftime('%Y%m%d')
end
operation = client.operation.create_resource.campaign(campaign)
response = client.service.campaign.mutate_campaigns(
customer_id: customer_id,
operations: [operation],
)
puts("Created campaign with ID: #{response.results.first.resource_name}")
response.results.first.resource_name
end
Perl
sub create_campaign {
my ($api_client, $customer_id, $campaign_budget_resource_name) = @_;
# Create a campaign.
my $campaign = Google::Ads::GoogleAds::V16::Resources::Campaign->new({
name => "Interplanetary Cruise #" . uniqid(),
advertisingChannelType => SEARCH,
status => Google::Ads::GoogleAds::V16::Enums::CampaignStatusEnum::PAUSED,
manualCpc => Google::Ads::GoogleAds::V16::Common::ManualCpc->new(),
campaignBudget => $campaign_budget_resource_name,
# Enable the campaign for DSAs.
dynamicSearchAdsSetting =>
Google::Ads::GoogleAds::V16::Resources::DynamicSearchAdsSetting->new({
domainName => "example.com",
languageCode => "en"
}
),
# Optional: Set the start and end dates for the campaign, beginning one day from
# now and ending a month from now.
startDate => strftime("%Y%m%d", localtime(time + 60 * 60 * 24)),
endDate => strftime("%Y%m%d", localtime(time + 60 * 60 * 24 * 30)),
});
# Create a campaign operation.
my $campaign_operation =
Google::Ads::GoogleAds::V16::Services::CampaignService::CampaignOperation->
new({create => $campaign});
# Add the campaign.
my $campaigns_response = $api_client->CampaignService()->mutate({
customerId => $customer_id,
operations => [$campaign_operation]});
my $campaign_resource_name = $campaigns_response->{results}[0]{resourceName};
printf "Created campaign '%s'.\n", $campaign_resource_name;
return $campaign_resource_name;
}
Créer le groupe d'annonces
Pour utiliser les fonctionnalités des annonces dynamiques du Réseau de Recherche, vous devez créer une AdGroup avec le champ type défini sur SEARCH_DYNAMIC_ADS.
Ce type de groupe d'annonces applique les restrictions suivantes:
- Vous ne pouvez ajouter ce type de groupe d'annonces qu'aux campagnes sur le Réseau de Recherche.
- Un
DynamicSearchAdsSettingvalide doit être défini au niveau de la campagne. - au groupe d'annonces à ajouter. Une erreur
AdGroupError.CANNOT_ADD_ADGROUP_OF_TYPE_DSA_TO_CAMPAIGN_WITHOUT_DSA_SETTINGest générée si ce paramètre est manquant. - Aucun mot clé à inclure n'est autorisé dans ce type de groupe d'annonces. L'audience, les cibles d'annonces dynamiques et les mots clés à exclure sont autorisés.
- Comme pour tous les groupes d'annonces, une fois créé, le champ
typene peut plus être modifié. - Seuls les formats d'annonces dynamiques du Réseau de Recherche sont autorisés dans ce groupe d'annonces.
L'exemple de code ci-dessous montre comment créer un groupe d'annonces SEARCH_DYNAMIC_ADS.
Java
private static String addAdGroup(
GoogleAdsClient googleAdsClient, long customerId, String campaignResourceName) {
// Creates the ad group.
AdGroup adGroup =
AdGroup.newBuilder()
.setName("Earth to Mars Cruises #" + getPrintableDateTime())
.setCampaign(campaignResourceName)
.setType(AdGroupType.SEARCH_DYNAMIC_ADS)
.setStatus(AdGroupStatus.PAUSED)
.setTrackingUrlTemplate("http://tracker.examples.com/traveltracker/{escapedlpurl}")
.setCpcBidMicros(50_000)
.build();
// Creates the operation.
AdGroupOperation operation = AdGroupOperation.newBuilder().setCreate(adGroup).build();
// Creates the ad group service client.
try (AdGroupServiceClient adGroupServiceClient =
googleAdsClient.getLatestVersion().createAdGroupServiceClient()) {
MutateAdGroupsResponse response =
adGroupServiceClient.mutateAdGroups(
Long.toString(customerId), ImmutableList.of(operation));
String adGroupResourceName = response.getResults(0).getResourceName();
// Displays the results.
System.out.printf("Added ad group with resource name '%s'.%n", adGroupResourceName);
return adGroupResourceName;
}
}
C#
private static string AddAdGroup(GoogleAdsClient client, long customerId,
string campaignResourceName)
{
// Get the AdGroupService.
AdGroupServiceClient adGroupService = client.GetService(Services.V16.AdGroupService);
// Create the ad group.
AdGroup adGroup = new AdGroup()
{
Name = "Earth to Mars Cruises #" + ExampleUtilities.GetRandomString(),
Campaign = campaignResourceName,
Type = AdGroupType.SearchDynamicAds,
Status = AdGroupStatus.Paused,
TrackingUrlTemplate = "http://tracker.examples.com/traveltracker/{escapedlpurl}",
CpcBidMicros = 50_000
};
// Create the operation.
AdGroupOperation operation = new AdGroupOperation()
{
Create = adGroup
};
// Add the ad group.
MutateAdGroupsResponse response =
adGroupService.MutateAdGroups(customerId.ToString(),
new AdGroupOperation[] { operation });
// Display the results.
string adGroupResourceName = response.Results[0].ResourceName;
Console.WriteLine($"Added ad group with resource name '{adGroupResourceName}'.");
return adGroupResourceName;
}
PHP
private static function createAdGroup(
GoogleAdsClient $googleAdsClient,
int $customerId,
string $campaignResourceName
) {
// Constructs an ad group and sets an optional CPC value.
$adGroup = new AdGroup([
'name' => 'Earth to Mars Cruises #' . Helper::getPrintableDatetime(),
'campaign' => $campaignResourceName,
'status' => AdGroupStatus::PAUSED,
'type' => AdGroupType::SEARCH_DYNAMIC_ADS,
'tracking_url_template' => 'http://tracker.examples.com/traveltracker/{escapedlpurl}',
'cpc_bid_micros' => 10000000
]);
// Creates an ad group operation.
$adGroupOperation = new AdGroupOperation();
$adGroupOperation->setCreate($adGroup);
// Issues a mutate request to add the ad groups.
$adGroupServiceClient = $googleAdsClient->getAdGroupServiceClient();
/** @var MutateAdGroupsResponse $adGroupResponse */
$adGroupResponse = $adGroupServiceClient->mutateAdGroups(
MutateAdGroupsRequest::build($customerId, [$adGroupOperation])
);
$adGroupResourceName = $adGroupResponse->getResults()[0]->getResourceName();
printf("Added ad group named '%s'.%s", $adGroupResourceName, PHP_EOL);
return $adGroupResourceName;
}
Python
def create_ad_group(client, customer_id, campaign_resource_name):
"""Creates a Dynamic Search Ad Group under the given Campaign.
Args:
client: an initialized GoogleAdsClient instance.
customer_id: a client customer ID str.
campaign_resource_name: a resource_name str for a Campaign.
Returns:
A resource_name str for the newly created Ad Group.
"""
# Retrieve a new ad group operation object.
ad_group_operation = client.get_type("AdGroupOperation")
# Create an ad group.
ad_group = ad_group_operation.create
# Required: set the ad group's type to Dynamic Search Ads.
ad_group.type_ = client.enums.AdGroupTypeEnum.SEARCH_DYNAMIC_ADS
ad_group.name = f"Earth to Mars Cruises {uuid4()}"
ad_group.campaign = campaign_resource_name
ad_group.status = client.enums.AdGroupStatusEnum.PAUSED
# Recommended: set a tracking URL template for your ad group if you want to
# use URL tracking software.
ad_group.tracking_url_template = (
"http://tracker.example.com/traveltracker/{escapedlpurl}"
)
# Optional: Set the ad group bid value.
ad_group.cpc_bid_micros = 10000000
# Retrieve the ad group service.
ad_group_service = client.get_service("AdGroupService")
# Issues a mutate request to add the ad group.
response = ad_group_service.mutate_ad_groups(
customer_id=customer_id, operations=[ad_group_operation]
)
resource_name = response.results[0].resource_name
print(f'Created Ad Group with resource_name: "{resource_name}"')
Ruby
def create_ad_group(client, customer_id, campaign_resource_name)
ad_group = client.resource.ad_group do |ag|
ag.type = :SEARCH_DYNAMIC_ADS
ag.name = "Earth to Mars Cruises #{(Time.now.to_f * 1000).to_i}"
ag.campaign = campaign_resource_name
ag.status = :PAUSED
ag.tracking_url_template = "http://tracker.example.com/traveltracker/{escapedlpurl}"
ag.cpc_bid_micros = 3_000_000
end
operation = client.operation.create_resource.ad_group(ad_group)
response = client.service.ad_group.mutate_ad_groups(
customer_id: customer_id,
operations: [operation],
)
puts("Created ad group with ID: #{response.results.first.resource_name}")
response.results.first.resource_name
end
Perl
sub create_ad_group {
my ($api_client, $customer_id, $campaign_resource_name) = @_;
# Construct an ad group and set an optional CPC value.
my $ad_group = Google::Ads::GoogleAds::V16::Resources::AdGroup->new({
name => "Earth to Mars Cruises #" . uniqid(),
campaign => $campaign_resource_name,
status => Google::Ads::GoogleAds::V16::Enums::AdGroupStatusEnum::PAUSED,
type => SEARCH_DYNAMIC_ADS,
trackingUrlTemplate =>
"http://tracker.examples.com/traveltracker/{escapedlpurl}",
cpcBidMicros => 3000000
});
# Create an ad group operation.
my $ad_group_operation =
Google::Ads::GoogleAds::V16::Services::AdGroupService::AdGroupOperation->
new({create => $ad_group});
# Add the ad group.
my $ad_groups_response = $api_client->AdGroupService()->mutate({
customerId => $customer_id,
operations => [$ad_group_operation]});
my $ad_group_resource_name = $ad_groups_response->{results}[0]{resourceName};
printf "Created ad group '%s'.\n", $ad_group_resource_name;
return $ad_group_resource_name;
}
Créer les ADR
Pour créer les ADR, vous devez utiliser un objet ExpandedDynamicSearchAdInfo et définir ses champs suivants:
- Obligatoire:
description - Facultatif:
description2
Le titre, l'URL à afficher et l'URL finale de cette annonce seront générés automatiquement au moment de la diffusion, en fonction des informations spécifiques au nom de domaine fournies par l'DynamicSearchAdsSetting définies au niveau de la campagne.
Java
private static void addExpandedDSA(
GoogleAdsClient googleAdsClient, long customerId, String adGroupResourceName) {
// Creates an ad group ad.
AdGroupAd adGroupAd =
AdGroupAd.newBuilder()
.setAdGroup(adGroupResourceName)
.setStatus(AdGroupAdStatus.PAUSED)
// Sets the ad as an expanded dynamic search ad
.setAd(
Ad.newBuilder()
.setExpandedDynamicSearchAd(
ExpandedDynamicSearchAdInfo.newBuilder()
.setDescription("Buy tickets now!")
.build())
.build())
.build();
// Creates the operation.
AdGroupAdOperation operation = AdGroupAdOperation.newBuilder().setCreate(adGroupAd).build();
// Creates the ad group ad service client.
try (AdGroupAdServiceClient adGroupAdServiceClient =
googleAdsClient.getLatestVersion().createAdGroupAdServiceClient()) {
// Adds the dynamic search ad.
MutateAdGroupAdsResponse response =
adGroupAdServiceClient.mutateAdGroupAds(
Long.toString(customerId), ImmutableList.of(operation));
// Displays the response.
System.out.printf(
"Added ad group ad with resource name '%s'.%n", response.getResults(0).getResourceName());
}
}
C#
private static void AddExpandedDSA(GoogleAdsClient client, long customerId,
string adGroupResourceName)
{
// Get the AdGroupAdService.
AdGroupAdServiceClient adGroupAdService =
client.GetService(Services.V16.AdGroupAdService);
// Create an ad group ad.
AdGroupAd adGroupAd = new AdGroupAd()
{
AdGroup = adGroupResourceName,
Status = AdGroupAdStatus.Paused,
// Set the ad as an expanded dynamic search ad.
Ad = new Ad()
{
ExpandedDynamicSearchAd = new ExpandedDynamicSearchAdInfo()
{
Description = "Buy tickets now!"
}
}
};
// Create the operation.
AdGroupAdOperation operation = new AdGroupAdOperation()
{
Create = adGroupAd
};
// Add the dynamic search ad.
MutateAdGroupAdsResponse response = adGroupAdService.MutateAdGroupAds(
customerId.ToString(), new AdGroupAdOperation[] { operation });
// Display the response.
Console.WriteLine($"Added ad group ad with resource name " +
$"'{response.Results[0].ResourceName}'.");
}
PHP
private static function createExpandedDSA(
GoogleAdsClient $googleAdsClient,
int $customerId,
string $adGroupResourceName
) {
$adGroupAd = new AdGroupAd([
'ad_group' => $adGroupResourceName,
'status' => AdGroupAdStatus::PAUSED,
'ad' => new Ad([
'expanded_dynamic_search_ad' => new ExpandedDynamicSearchAdInfo([
'description' => 'Buy tickets now!'
])
])
]);
$adGroupAdOperation = new AdGroupAdOperation();
$adGroupAdOperation->setCreate($adGroupAd);
// Issues a mutate request to add the ad group ads.
$adGroupAdServiceClient = $googleAdsClient->getAdGroupAdServiceClient();
/** @var MutateAdGroupAdsResponse $adGroupAdResponse */
$adGroupAdResponse = $adGroupAdServiceClient->mutateAdGroupAds(
MutateAdGroupAdsRequest::build($customerId, [$adGroupAdOperation])
);
$adGroupAdResourceName = $adGroupAdResponse->getResults()[0]->getResourceName();
printf("Added ad group ad named '%s'.%s", $adGroupAdResourceName, PHP_EOL);
return $adGroupAdResourceName;
}
Python
def create_expanded_dsa(client, customer_id, ad_group_resource_name):
"""Creates a dynamic search ad under the given ad group.
Args:
client: an initialized GoogleAdsClient instance.
customer_id: a client customer ID str.
ad_group_resource_name: a resource_name str for an Ad Group.
"""
# Retrieve a new ad group ad operation object.
ad_group_ad_operation = client.get_type("AdGroupAdOperation")
# Create and expanded dynamic search ad. This ad will have its headline,
# display URL and final URL auto-generated at serving time according to
# domain name specific information provided by DynamicSearchAdSetting at
# the campaign level.
ad_group_ad = ad_group_ad_operation.create
# Optional: set the ad status.
ad_group_ad.status = client.enums.AdGroupAdStatusEnum.PAUSED
# Set the ad description.
ad_group_ad.ad.expanded_dynamic_search_ad.description = "Buy tickets now!"
ad_group_ad.ad_group = ad_group_resource_name
# Retrieve the ad group ad service.
ad_group_ad_service = client.get_service("AdGroupAdService")
# Submit the ad group ad operation to add the ad group ad.
response = ad_group_ad_service.mutate_ad_group_ads(
customer_id=customer_id, operations=[ad_group_ad_operation]
)
resource_name = response.results[0].resource_name
print(f'Created Ad Group Ad with resource_name: "{resource_name}"')
Ruby
def create_expanded_dsa(client, customer_id, ad_group_resource_name)
ad_group_ad = client.resource.ad_group_ad do |aga|
aga.status = :PAUSED
aga.ad = client.resource.ad do |ad|
ad.expanded_dynamic_search_ad = client.resource.expanded_dynamic_search_ad_info do |info|
info.description = "Buy tickets now!"
end
end
aga.ad_group = ad_group_resource_name
end
operation = client.operation.create_resource.ad_group_ad(ad_group_ad)
response = client.service.ad_group_ad.mutate_ad_group_ads(
customer_id: customer_id,
operations: [operation],
)
puts("Created ad group ad with ID: #{response.results.first.resource_name}")
end
Perl
sub create_expanded_dsa {
my ($api_client, $customer_id, $ad_group_resource_name) = @_;
# Create an ad group ad.
my $ad_group_ad = Google::Ads::GoogleAds::V16::Resources::AdGroupAd->new({
adGroup => $ad_group_resource_name,
status => Google::Ads::GoogleAds::V16::Enums::AdGroupAdStatusEnum::PAUSED,
ad => Google::Ads::GoogleAds::V16::Resources::Ad->new({
expandedDynamicSearchAd =>
Google::Ads::GoogleAds::V16::Common::ExpandedDynamicSearchAdInfo->
new({
description => "Buy tickets now!"
})})});
# Create an ad group ad operation.
my $ad_group_ad_operation =
Google::Ads::GoogleAds::V16::Services::AdGroupAdService::AdGroupAdOperation
->new({create => $ad_group_ad});
# Add the ad group ad.
my $ad_group_ads_response = $api_client->AdGroupAdService()->mutate({
customerId => $customer_id,
operations => [$ad_group_ad_operation]});
my $ad_group_ad_resource_name =
$ad_group_ads_response->{results}[0]{resourceName};
printf "Created ad group ad '%s'.\n", $ad_group_ad_resource_name;
return $ad_group_ad_resource_name;
}
Le champ final_urls est calculé par Google Ads lors de la création de l'ADR. Par conséquent, vous ne pouvez pas définir ce champ lorsque vous créez des annonces dynamiques du Réseau de Recherche. Pour utiliser un logiciel de suivi des URL, vous pouvez spécifier les paramètres de suivi ou les redirections supplémentaires nécessaires à l'aide du champ tracking_url_template. Lorsque vous spécifiez ce champ, vous devez inclure l'un des paramètres suivants pour permettre à Google Ads d'insérer l'URL finale correspondante obtenue:
| Paramètres | Explication |
|---|---|
{unescapedlpurl} |
URL de page de destination sans échappement (si vous souhaitez ajouter quelque chose à la fin, par exemple:
|
{escapedlpurl} |
URL de la page de destination avec échappement (encodée au format URL), si vous souhaitez rediriger vers un outil de suivi, par exemple:
|
{lpurlpath} |
Seuls les paramètres de chemin d'accès et de requête de l'URL calculée, par exemple:
|
{lpurl} |
Encode
|
Exemple :
Java
dsa.setTrackingUrlTemplate(
StringValue.of("http://example.com/traveltracker/{escapedlpurl}"));
Spécifiez les critères des annonces dynamiques du Réseau de Recherche.
Enfin, vous devez définir des critères de déclenchement de la diffusion des annonces dynamiques du Réseau de Recherche.
Pour ce faire, utilisez le champ webpage de AdGroupCriterion. Ce champ webpage est défini en tant qu'objet WebpageInfo, ce qui autorise entre un et trois conditions.
Ces conditions sont des instances WebpageConditionInfo qui vous permettent de spécifier exactement les éléments à filtrer ou à rechercher dans le domaine spécifié précédemment dans les paramètres de la campagne. Vous pouvez filtrer les cinq éléments d'un domaine:
| WebpageConditionOperand | Description |
|---|---|
URL |
Chaîne correspondant à une URL partielle d'une page. |
CATEGORY |
Chaîne avec une catégorie à laquelle faire correspondre avec précision. |
PAGE_TITLE |
Chaîne correspondant à une partie du titre d'une page. |
PAGE_CONTENT |
Chaîne correspondant à un certain contenu d'une page indexée donnée. |
CUSTOM_LABEL |
Chaîne correspondant à une condition de ciblage de l'étiquette personnalisée d'une page Web. Consultez Cibler des URL de flux de pages à l'aide d'étiquettes personnalisées. |
Par exemple, vous pouvez créer un critère de page Web qui cible tous les éléments situés dans la branche /children d'un site de vacances (condition URL), mais uniquement les pages dont le titre contient "Offre spéciale" (condition PAGE_TITLE).
Découvrir les catégories du site
Vous pouvez récupérer et filtrer la liste des DomainCategory qui, selon Google, s'appliquent à votre site, en sélectionnant les champs de la ressource domain_category dans une requête GAQL.
La requête GAQL suivante récupère la liste des catégories de domaines pour un site et une campagne spécifiques, en les filtrant par ID:
SELECT
domain_category.category,
domain_category.language_code,
domain_category.recommended_cpc_bid_micros
FROM domain_category
WHERE domain_category.domain = 'example.com'
AND campaign.id = campaign_id
Exclusion de parties du site
Vous pouvez également utiliser AdGroupCriterionService pour configurer des critères de page Web à exclure. Cette option vous permet, par exemple, d'exclure des pages portant un titre particulier que vous souhaitez gérer avec une autre campagne ou un autre groupe d'annonces.
Autres critères
Les campagnes et les groupes d'annonces dynamiques du Réseau de Recherche ne sont pas limités aux seuls critères relatifs aux pages Web. Vous pouvez continuer à utiliser d'autres types de critères pour affiner et améliorer la qualité de vos annonces. Toutefois, nous vous conseillons d'utiliser les autres critères de façon réfléchie, car en ajouter trop peut diminuer l'efficacité du ciblage automatique des annonces dynamiques du Réseau de Recherche.