The code samples below provide examples of common advanced operations using the AdWords API. Client Library.
Add an ad customizer feed
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; using System.Collections.Generic; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds an ad customizer feed. Then it adds an ad in two /// different ad groups that uses the feed to populate dynamic data. /// </summary> public class AddAdCustomizers : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddAdCustomizers codeExample = new AddAdCustomizers(); Console.WriteLine(codeExample.Description); try { long adGroupId1 = long.Parse("INSERT_ADGROUP_ID_HERE"); long adGroupId2 = long.Parse("INSERT_ADGROUP_ID_HERE"); string feedName = "INSERT_FEED_NAME_HERE"; codeExample.Run(new AdWordsUser(), adGroupId1, adGroupId2, feedName); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds an ad customizer feed. Then it adds an ad in two " + "different ad groups that uses the feed to populate dynamic data."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId1">Id of the first adgroup to which ads with ad /// customizers are added.</param> /// <param name="adGroupId2">Id of the second adgroup to which ads with ad /// customizers are added.</param> /// <param name="feedName">Name of the feed to be created.</param> public void Run(AdWordsUser user, long adGroupId1, long adGroupId2, string feedName) { try { // Create a customizer feed. One feed per account can be used for all ads. AdCustomizerFeed adCustomizerFeed = CreateCustomizerFeed(user, feedName); // Add feed items containing the values we'd like to place in ads. CreateCustomizerFeedItems(user, new long[] { adGroupId1, adGroupId2 }, adCustomizerFeed); // All set! We can now create ads with customizations. CreateAdsWithCustomizations(user, new long[] { adGroupId1, adGroupId2 }, feedName); } catch (Exception e) { throw new System.ApplicationException("Failed to add ad customizers.", e); } } /// <summary> /// Creates a new Feed for ad customizers. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="feedName">Name of the feed to be created.</param> /// <returns>A new Ad customizer feed.</returns> private static AdCustomizerFeed CreateCustomizerFeed(AdWordsUser user, string feedName) { using (AdCustomizerFeedService adCustomizerFeedService = (AdCustomizerFeedService) user.GetService(AdWordsService.v201809 .AdCustomizerFeedService)) { AdCustomizerFeed feed = new AdCustomizerFeed() { feedName = feedName, feedAttributes = new AdCustomizerFeedAttribute[] { new AdCustomizerFeedAttribute() { name = "Name", type = AdCustomizerFeedAttributeType.STRING }, new AdCustomizerFeedAttribute() { name = "Price", type = AdCustomizerFeedAttributeType.PRICE }, new AdCustomizerFeedAttribute() { name = "Date", type = AdCustomizerFeedAttributeType.DATE_TIME }, } }; AdCustomizerFeedOperation feedOperation = new AdCustomizerFeedOperation() { operand = feed, @operator = (Operator.ADD) }; AdCustomizerFeed addedFeed = adCustomizerFeedService.mutate( new AdCustomizerFeedOperation[] { feedOperation }).value[0]; Console.WriteLine( "Created ad customizer feed with ID = {0} and name = '{1}' and " + "attributes: ", addedFeed.feedId, addedFeed.feedName); foreach (AdCustomizerFeedAttribute feedAttribute in addedFeed.feedAttributes) { Console.WriteLine(" ID: {0}, name: '{1}', type: {2}", feedAttribute.id, feedAttribute.name, feedAttribute.type); } return addedFeed; } } /// <summary> /// Restricts the feed item to an ad group. /// </summary> /// <param name="user">The user.</param> /// <param name="feedItem">The feed item.</param> /// <param name="adGroupId">The ad group ID.</param> private static void RestrictFeedItemToAdGroup(AdWordsUser user, FeedItem feedItem, long? adGroupId) { FeedItemAdGroupTarget adGroupTarget = new FeedItemAdGroupTarget() { feedId = feedItem.feedId, feedItemId = feedItem.feedItemId, adGroupId = adGroupId.Value }; using (FeedItemTargetService feedItemTargetService = (FeedItemTargetService) user.GetService( AdWordsService.v201809.FeedItemTargetService)) { FeedItemTargetOperation operation = new FeedItemTargetOperation() { @operator = Operator.ADD, operand = adGroupTarget }; FeedItemTargetReturnValue retval = feedItemTargetService.mutate( new FeedItemTargetOperation[] { operation }); FeedItemAdGroupTarget newAdGroupTarget = (FeedItemAdGroupTarget) retval.value[0]; Console.WriteLine( "Feed item target for feed ID {0} and feed item ID {1}" + " was created to restrict serving to ad group ID {2}", newAdGroupTarget.feedId, newAdGroupTarget.feedItemId, newAdGroupTarget.adGroupId); } } /// <summary> /// Creates feed items with the values to use in ad customizations for each /// ad group in <code>adGroupIds</code>. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupIds">IDs of adgroups to which ad customizations are /// made.</param> /// <param name="adCustomizerFeed">The ad customizer feed.</param> private static void CreateCustomizerFeedItems(AdWordsUser user, long[] adGroupIds, AdCustomizerFeed adCustomizerFeed) { using (FeedItemService feedItemService = (FeedItemService) user.GetService(AdWordsService.v201809.FeedItemService)) { List<FeedItemOperation> feedItemOperations = new List<FeedItemOperation>(); DateTime marsDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1); feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Mars", "$1234.56", marsDate.ToString("yyyyMMdd HHmmss"))); DateTime venusDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 15); feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Venus", "$1450.00", venusDate.ToString("yyyyMMdd HHmmss"))); FeedItemReturnValue feedItemReturnValue = feedItemService.mutate(feedItemOperations.ToArray()); foreach (FeedItem addedFeedItem in feedItemReturnValue.value) { Console.WriteLine("Added feed item with ID {0}", addedFeedItem.feedItemId); } // Add feed item targeting to restrict the feed item to specific ad groups. RestrictFeedItemToAdGroup(user, feedItemReturnValue.value[0], adGroupIds[0]); RestrictFeedItemToAdGroup(user, feedItemReturnValue.value[1], adGroupIds[1]); } } /// <summary> /// Creates a FeedItemOperation that will create a FeedItem with the /// specified values when sent to FeedItemService.mutate. /// </summary> /// <param name="adCustomizerFeed">The ad customizer feed.</param> /// <param name="name">The value for the name attribute of the FeedItem. /// </param> /// <param name="price">The value for the price attribute of the FeedItem. /// </param> /// <param name="date">The value for the date attribute of the FeedItem. /// </param> /// <returns>A new FeedItemOperation for adding a FeedItem.</returns> private static FeedItemOperation CreateFeedItemAddOperation( AdCustomizerFeed adCustomizerFeed, string name, string price, string date) { FeedItem feedItem = new FeedItem() { feedId = adCustomizerFeed.feedId, // FeedAttributes appear in the same order as they were created // - Name, Price, Date. See CreateCustomizerFeed method for details. attributeValues = new FeedItemAttributeValue[] { new FeedItemAttributeValue() { feedAttributeId = adCustomizerFeed.feedAttributes[0].id, stringValue = name }, new FeedItemAttributeValue() { feedAttributeId = adCustomizerFeed.feedAttributes[1].id, stringValue = price }, new FeedItemAttributeValue() { feedAttributeId = adCustomizerFeed.feedAttributes[2].id, stringValue = date } }, }; return new FeedItemOperation() { operand = feedItem, @operator = Operator.ADD }; } /// <summary> /// Creates text ads that use ad customizations for the specified ad group /// IDs. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupIds">IDs of the ad groups to which customized ads /// are added.</param> /// <param name="feedName">Name of the feed to be used.</param> private static void CreateAdsWithCustomizations(AdWordsUser user, long[] adGroupIds, string feedName) { using (AdGroupAdService adGroupAdService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { ExpandedTextAd expandedTextAd = new ExpandedTextAd() { headlinePart1 = string.Format("Luxury Cruise to {{={0}.Name}}", feedName), headlinePart2 = string.Format("Only {{={0}.Price}}", feedName), description = string.Format("Offer ends in {{=countdown({0}.Date)}}!", feedName), finalUrls = new string[] { "http://www.example.com" } }; // We add the same ad to both ad groups. When they serve, they will show // different values, since they match different feed items. List<AdGroupAdOperation> adGroupAdOperations = new List<AdGroupAdOperation>(); foreach (long adGroupId in adGroupIds) { AdGroupAd adGroupAd = new AdGroupAd() { adGroupId = adGroupId, ad = expandedTextAd }; AdGroupAdOperation adGroupAdOperation = new AdGroupAdOperation() { operand = adGroupAd, @operator = Operator.ADD }; adGroupAdOperations.Add(adGroupAdOperation); } AdGroupAdReturnValue adGroupAdReturnValue = adGroupAdService.mutate(adGroupAdOperations.ToArray()); foreach (AdGroupAd addedAd in adGroupAdReturnValue.value) { Console.WriteLine("Created an ad with ID {0}, type '{1}' and status '{2}'.", addedAd.ad.id, addedAd.ad.AdType, addedAd.status); } } } } }
Add an ad group level bid modifier
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example illustrates how to add ad group level mobile bid /// modifier override. /// </summary> public class AddAdGroupBidModifier : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddAdGroupBidModifier codeExample = new AddAdGroupBidModifier(); Console.WriteLine(codeExample.Description); try { long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE"); double bidModifier = double.Parse("INSERT_ADGROUP_BID_MODIFIER_HERE"); codeExample.Run(new AdWordsUser(), adGroupId, bidModifier); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example illustrates how to add ad group level mobile bid modifier " + "override."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Id of the adgroup for which bid modifier is /// set.</param> /// <param name="bidModifier">The mobile bid modifier for adgroup</param> public void Run(AdWordsUser user, long adGroupId, double bidModifier) { using (AdGroupBidModifierService adGroupBidModifierService = (AdGroupBidModifierService) user.GetService(AdWordsService.v201809 .AdGroupBidModifierService)) { // Mobile criterion ID. long criterionId = 30001; // Create the adgroup bid modifier. AdGroupBidModifier adGroupBidModifier = new AdGroupBidModifier { bidModifier = bidModifier, adGroupId = adGroupId }; Platform platform = new Platform { id = criterionId }; adGroupBidModifier.criterion = platform; AdGroupBidModifierOperation operation = new AdGroupBidModifierOperation { @operator = Operator.ADD, operand = adGroupBidModifier }; try { // Add ad group level mobile bid modifier. AdGroupBidModifierReturnValue retval = adGroupBidModifierService.mutate( new AdGroupBidModifierOperation[] { operation }); // Display the results. if (retval != null && retval.value != null && retval.value.Length > 0) { AdGroupBidModifier newBidModifier = retval.value[0]; Console.WriteLine( "AdGroup ID {0}, Criterion ID {1} was updated with ad group level " + "modifier: {2}", newBidModifier.adGroupId, newBidModifier.criterion.id, newBidModifier.bidModifier); } else { Console.WriteLine("No bid modifiers were added to the adgroup."); } } catch (Exception e) { throw new System.ApplicationException("Failed to add bid modifiers to adgroup.", e); } } } } }
Add a page feed specifying URLs for a DSA campaign
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds a page feed to specify precisely which URLs to use with your /// Dynamic Search Ads campaign. To create a Dynamic Search Ads campaign, run /// AddDynamicSearchAdsCampaign.cs. To get campaigns, run GetCampaigns.cs. /// </summary> public class AddDynamicPageFeed : ExampleBase { /// <summary> /// The criterion type to be used for DSA page feeds. /// </summary> /// <remarks>DSA page feeds use criterionType field instead of the placeholderType field /// unlike most other feed types.</remarks> private const int DSA_PAGE_FEED_CRITERION_TYPE = 61; /// <summary> /// ID that corresponds to the page URLs. /// </summary> private const int DSA_PAGE_URLS_FIELD_ID = 1; /// <summary> /// ID that corresponds to the labels. /// </summary> private const int DSA_LABEL_FIELD_ID = 2; /// <summary> /// Class to keep track of DSA page feed details. /// </summary> private class DSAFeedDetails { public long feedId { get; set; } public long urlAttributeId { get; set; } public long labelAttributeId { get; set; } } /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddDynamicPageFeed codeExample = new AddDynamicPageFeed(); Console.WriteLine(codeExample.Description); try { long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE"); long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE"); codeExample.Run(new AdWordsUser(), campaignId, adGroupId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds a page feed to specify precisely which URLs to " + "use with your Dynamic Search Ads campaign. To create a Dynamic Search Ads " + "campaign, run AddDynamicSearchAdsCampaign.cs. To get campaigns, " + "run GetCampaigns.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">The DSA campaign ID.</param> /// <param name="adGroupId">The DSA ad group ID.</param> public void Run(AdWordsUser user, long campaignId, long adGroupId) { string dsaPageUrlLabel = "discounts"; // Get the page feed details. This code example creates a new feed, but you can // fetch and re-use an existing feed. DSAFeedDetails feedDetails = CreateFeed(user); CreateFeedMapping(user, feedDetails); CreateFeedItems(user, feedDetails, dsaPageUrlLabel); // Associate the page feed with the campaign. UpdateCampaignDsaSetting(user, campaignId, feedDetails.feedId); // Optional: Target web pages matching the feed's label in the ad group. AddDsaTargeting(user, adGroupId, dsaPageUrlLabel); Console.WriteLine("Dynamic page feed setup is complete for campaign ID '{0}'.", campaignId); } /// <summary> /// Creates the feed for DSA page URLs. /// </summary> /// <param name="user">The AdWords User.</param> /// <returns>The feed details.</returns> private static DSAFeedDetails CreateFeed(AdWordsUser user) { using (FeedService feedService = (FeedService) user.GetService(AdWordsService.v201809.FeedService)) { // Create attributes. FeedAttribute urlAttribute = new FeedAttribute { type = FeedAttributeType.URL_LIST, name = "Page URL" }; FeedAttribute labelAttribute = new FeedAttribute { type = FeedAttributeType.STRING_LIST, name = "Label" }; // Create the feed. Feed sitelinksFeed = new Feed { name = "DSA Feed " + ExampleUtilities.GetRandomString(), attributes = new FeedAttribute[] { urlAttribute, labelAttribute }, origin = FeedOrigin.USER }; // Create operation. FeedOperation operation = new FeedOperation { operand = sitelinksFeed, @operator = Operator.ADD }; try { // Add the feed. FeedReturnValue result = feedService.mutate(new FeedOperation[] { operation }); Feed savedFeed = result.value[0]; return new DSAFeedDetails { feedId = savedFeed.id, urlAttributeId = savedFeed.attributes[0].id, labelAttributeId = savedFeed.attributes[1].id, }; } catch (Exception e) { throw new System.ApplicationException("Failed to create DSA feed.", e); } } } /// <summary> /// Creates the feed mapping for DSA page feeds. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="feedDetails">The feed details.</param> private static void CreateFeedMapping(AdWordsUser user, DSAFeedDetails feedDetails) { using (FeedMappingService feedMappingService = (FeedMappingService) user.GetService(AdWordsService.v201809.FeedMappingService)) { // Map the FeedAttributeIds to the fieldId constants. AttributeFieldMapping urlFieldMapping = new AttributeFieldMapping { feedAttributeId = feedDetails.urlAttributeId, fieldId = DSA_PAGE_URLS_FIELD_ID }; AttributeFieldMapping labelFieldMapping = new AttributeFieldMapping { feedAttributeId = feedDetails.labelAttributeId, fieldId = DSA_LABEL_FIELD_ID }; // Create the FieldMapping and operation. FeedMapping feedMapping = new FeedMapping { criterionType = DSA_PAGE_FEED_CRITERION_TYPE, feedId = feedDetails.feedId, attributeFieldMappings = new AttributeFieldMapping[] { urlFieldMapping, labelFieldMapping } }; FeedMappingOperation operation = new FeedMappingOperation { operand = feedMapping, @operator = Operator.ADD }; try { // Add the field mapping. feedMappingService.mutate(new FeedMappingOperation[] { operation }); return; } catch (Exception e) { throw new System.ApplicationException("Failed to create feed mapping.", e); } } } /// <summary> /// Creates the page URLs in the DSA page feed. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="feedDetails">The feed details.</param> /// <param name="labelName">The pagefeed url label.</param> private static void CreateFeedItems(AdWordsUser user, DSAFeedDetails feedDetails, string labelName) { using (FeedItemService feedItemService = (FeedItemService) user.GetService(AdWordsService.v201809.FeedItemService)) { FeedItemOperation[] operations = new FeedItemOperation[] { CreateDsaUrlAddOperation(feedDetails, "http://www.example.com/discounts/rental-cars", labelName), CreateDsaUrlAddOperation(feedDetails, "http://www.example.com/discounts/hotel-deals", labelName), CreateDsaUrlAddOperation(feedDetails, "http://www.example.com/discounts/flight-deals", labelName), }; feedItemService.mutate(operations); } } /// <summary> /// Creates the DSA URL add operation. /// </summary> /// <param name="details">The page feed details.</param> /// <param name="url">The DSA page feed URL.</param> /// <param name="label">DSA page feed label.</param> /// <returns>The DSA URL add operation.</returns> private static FeedItemOperation CreateDsaUrlAddOperation(DSAFeedDetails details, string url, string label) { // Create the FeedItemAttributeValues for our text values. FeedItemAttributeValue urlAttributeValue = new FeedItemAttributeValue { feedAttributeId = details.urlAttributeId, // See https://support.google.com/adwords/answer/7166527 for page feed URL // recommendations and rules. stringValues = new string[] { url } }; FeedItemAttributeValue labelAttributeValue = new FeedItemAttributeValue { feedAttributeId = details.labelAttributeId, stringValues = new string[] { label } }; // Create the feed item and operation. FeedItem item = new FeedItem { feedId = details.feedId, attributeValues = new FeedItemAttributeValue[] { urlAttributeValue, labelAttributeValue } }; FeedItemOperation operation = new FeedItemOperation { operand = item, @operator = Operator.ADD }; return operation; } /// <summary> /// Updates the campaign DSA setting to add DSA pagefeeds. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">The Campaign ID.</param> /// <param name="feedId">The page feed ID.</param> private static void UpdateCampaignDsaSetting(AdWordsUser user, long campaignId, long feedId) { using (CampaignService campaignService = (CampaignService) user.GetService(AdWordsService.v201809.CampaignService)) { Selector selector = new Selector() { fields = new string[] { Campaign.Fields.Id, Campaign.Fields.Settings }, predicates = new Predicate[] { Predicate.Equals(Campaign.Fields.Id, campaignId) }, paging = Paging.Default }; CampaignPage page = campaignService.get(selector); if (page == null || page.entries == null || page.entries.Length == 0) { throw new System.ApplicationException( string.Format("Failed to retrieve campaign with ID = {0}.", campaignId)); } Campaign campaign = page.entries[0]; if (campaign.settings == null) { throw new System.ApplicationException("This is not a DSA campaign."); } DynamicSearchAdsSetting dsaSetting = null; Setting[] campaignSettings = campaign.settings; for (int i = 0; i < campaign.settings.Length; i++) { Setting setting = campaignSettings[i]; if (setting is DynamicSearchAdsSetting) { dsaSetting = (DynamicSearchAdsSetting) setting; break; } } if (dsaSetting == null) { throw new System.ApplicationException("This is not a DSA campaign."); } // Use a page feed to specify precisely which URLs to use with your // Dynamic Search Ads. dsaSetting.pageFeed = new PageFeed() { feedIds = new long[] { feedId }, }; // Optional: Specify whether only the supplied URLs should be used with your // Dynamic Search Ads. dsaSetting.useSuppliedUrlsOnly = true; Campaign campaignToUpdate = new Campaign { id = campaignId, settings = campaignSettings }; CampaignOperation operation = new CampaignOperation { operand = campaignToUpdate, @operator = Operator.SET }; try { CampaignReturnValue retval = campaignService.mutate(new CampaignOperation[] { operation }); Campaign updatedCampaign = retval.value[0]; Console.WriteLine( "DSA page feed for campaign ID '{0}' was updated with feed ID '{1}'.", updatedCampaign.id, feedId); } catch (Exception e) { throw new System.ApplicationException("Failed to set page feed for campaign.", e); } } } /// <summary> /// Set custom targeting for the page feed URLs based on a list of labels. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Ad group ID.</param> /// <param name="labelName">The label name.</param> /// <returns>The newly created webpage criterion.</returns> private static BiddableAdGroupCriterion AddDsaTargeting(AdWordsUser user, long adGroupId, string labelName) { using (AdGroupCriterionService adGroupCriterionService = (AdGroupCriterionService) user.GetService(AdWordsService.v201809 .AdGroupCriterionService)) { // Create a webpage criterion. Webpage webpage = new Webpage(); WebpageParameter parameter = new WebpageParameter { criterionName = "Test criterion" }; webpage.parameter = parameter; // Add a condition for label=specified_label_name. WebpageCondition condition = new WebpageCondition { operand = WebpageConditionOperand.CUSTOM_LABEL, argument = labelName }; parameter.conditions = new WebpageCondition[] { condition }; BiddableAdGroupCriterion criterion = new BiddableAdGroupCriterion { adGroupId = adGroupId, criterion = webpage }; // Set a custom bid for this criterion. BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration { bids = new Bids[] { new CpcBid() { bid = new Money() { microAmount = 1500000 } } } }; criterion.biddingStrategyConfiguration = biddingStrategyConfiguration; AdGroupCriterionOperation operation = new AdGroupCriterionOperation { operand = criterion, @operator = Operator.ADD }; try { AdGroupCriterionReturnValue retval = adGroupCriterionService.mutate( new AdGroupCriterionOperation[] { operation }); BiddableAdGroupCriterion newCriterion = (BiddableAdGroupCriterion) retval.value[0]; Console.WriteLine( "Web page criterion with ID = {0} and status = {1} was created.", newCriterion.criterion.id, newCriterion.userStatus); return newCriterion; } catch (Exception e) { throw new System.ApplicationException( "Failed to create webpage criterion for " + "custom page feed label.", e); } } } } }
Add a DSA campaign
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds a Dynamic Search Ads campaign. To get campaigns, run GetCampaigns.cs. /// </summary> public class AddDynamicSearchAdsCampaign : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddDynamicSearchAdsCampaign codeExample = new AddDynamicSearchAdsCampaign(); Console.WriteLine(codeExample.Description); try { codeExample.Run(new AdWordsUser()); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds a Dynamic Search Ads campaign. To get campaigns, " + "run GetCampaigns.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> public void Run(AdWordsUser user) { Budget budget = CreateBudget(user); Campaign campaign = CreateCampaign(user, budget); AdGroup adGroup = CreateAdGroup(user, campaign.id); CreateExpandedDSA(user, adGroup.id); AddWebPageCriteria(user, adGroup.id); Console.WriteLine("Dynamic Search Ads campaign setup is complete."); } /// <summary> /// Creates the budget. /// </summary> /// <param name="user">The AdWords user.</param> /// <returns>The newly created budget.</returns> private static Budget CreateBudget(AdWordsUser user) { using (BudgetService budgetService = (BudgetService) user.GetService(AdWordsService.v201809.BudgetService)) { // Create the campaign budget. Budget budget = new Budget { name = "Interplanetary Cruise Budget #" + ExampleUtilities.GetRandomString(), deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD, amount = new Money { microAmount = 500000 } }; BudgetOperation budgetOperation = new BudgetOperation { @operator = Operator.ADD, operand = budget }; try { BudgetReturnValue budgetRetval = budgetService.mutate(new BudgetOperation[] { budgetOperation }); Budget newBudget = budgetRetval.value[0]; Console.WriteLine("Budget with ID = '{0}' and name = '{1}' was created.", newBudget.budgetId, newBudget.name); budgetService.Close(); return newBudget; } catch (Exception e) { throw new System.ApplicationException("Failed to add budget.", e); } } } /// <summary> /// Creates the campaign. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="budget">The campaign budget.</param> /// <returns>The newly created campaign.</returns> private static Campaign CreateCampaign(AdWordsUser user, Budget budget) { using (CampaignService campaignService = (CampaignService) user.GetService(AdWordsService.v201809.CampaignService)) { // Create a Dynamic Search Ads campaign. Campaign campaign = new Campaign { name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(), advertisingChannelType = AdvertisingChannelType.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. status = CampaignStatus.PAUSED }; BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration { biddingStrategyType = BiddingStrategyType.MANUAL_CPC }; campaign.biddingStrategyConfiguration = biddingConfig; campaign.budget = new Budget { budgetId = budget.budgetId }; // Required: Set the campaign's Dynamic Search Ads settings. DynamicSearchAdsSetting dynamicSearchAdsSetting = new DynamicSearchAdsSetting { // Required: Set the domain name and language. domainName = "example.com", languageCode = "en" }; // Set the campaign settings. campaign.settings = new Setting[] { dynamicSearchAdsSetting }; // Optional: Set the start date. campaign.startDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd"); // Optional: Set the end date. campaign.endDate = DateTime.Now.AddYears(1).ToString("yyyyMMdd"); // Create the operation. CampaignOperation operation = new CampaignOperation { @operator = Operator.ADD, operand = campaign }; try { // Add the campaign. CampaignReturnValue retVal = campaignService.mutate(new CampaignOperation[] { operation }); // Display the results. Campaign newCampaign = retVal.value[0]; Console.WriteLine("Campaign with id = '{0}' and name = '{1}' was added.", newCampaign.id, newCampaign.name); return newCampaign; } catch (Exception e) { throw new System.ApplicationException("Failed to add campaigns.", e); } } } /// <summary> /// Creates an ad group. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">The campaign ID.</param> /// <returns>the newly created ad group.</returns> private static AdGroup CreateAdGroup(AdWordsUser user, long campaignId) { using (AdGroupService adGroupService = (AdGroupService) user.GetService(AdWordsService.v201809.AdGroupService)) { // Create the ad group. AdGroup adGroup = new AdGroup { // Required: Set the ad group's type to Dynamic Search Ads. adGroupType = AdGroupType.SEARCH_DYNAMIC_ADS, name = string.Format("Earth to Mars Cruises #{0}", ExampleUtilities.GetRandomString()), campaignId = campaignId, status = AdGroupStatus.PAUSED, // Recommended: Set a tracking URL template for your ad group if you want to use // URL tracking software. trackingUrlTemplate = "http://tracker.example.com/traveltracker/{escapedlpurl}" }; // Set the ad group bids. BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration(); CpcBid cpcBid = new CpcBid { bid = new Money { microAmount = 3000000 } }; biddingConfig.bids = new Bids[] { cpcBid }; adGroup.biddingStrategyConfiguration = biddingConfig; // Create the operation. AdGroupOperation operation = new AdGroupOperation { @operator = Operator.ADD, operand = adGroup }; try { // Create the ad group. AdGroupReturnValue retVal = adGroupService.mutate(new AdGroupOperation[] { operation }); // Display the results. AdGroup newAdGroup = retVal.value[0]; Console.WriteLine("Ad group with id = '{0}' and name = '{1}' was created.", newAdGroup.id, newAdGroup.name); return newAdGroup; } catch (Exception e) { throw new System.ApplicationException("Failed to create ad group.", e); } } } /// <summary> /// Creates an expanded Dynamic Search Ad. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">ID of the ad group in which ad is created.</param> /// <returns>The newly created ad.</returns> private static ExpandedDynamicSearchAd CreateExpandedDSA(AdWordsUser user, long adGroupId) { using (AdGroupAdService adGroupAdService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { // Create an 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 DynamicSearchAdsSetting at the campaign level. ExpandedDynamicSearchAd expandedDSA = new ExpandedDynamicSearchAd { // Set the ad description. description = "Buy your tickets now!", description2 = "Discount ends soon" }; // Create the ad group ad. AdGroupAd adGroupAd = new AdGroupAd { adGroupId = adGroupId, ad = expandedDSA, // Optional: Set the status. status = AdGroupAdStatus.PAUSED }; // Create the operation. AdGroupAdOperation operation = new AdGroupAdOperation { @operator = Operator.ADD, operand = adGroupAd }; try { // Create the ad. AdGroupAdReturnValue retval = adGroupAdService.mutate(new AdGroupAdOperation[] { operation }); // Display the results. AdGroupAd newAdGroupAd = retval.value[0]; ExpandedDynamicSearchAd newAd = newAdGroupAd.ad as ExpandedDynamicSearchAd; Console.WriteLine( "Expanded Dynamic Search Ad with ID '{0}' and description '{1}' " + "was added.", newAd.id, newAd.description); return newAd; } catch (Exception e) { throw new System.ApplicationException( "Failed to create Expanded Dynamic Search Ad.", e); } } } /// <summary> /// Adds a web page criterion to target Dynamic Search Ads. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">The ad group ID.</param> /// <returns>The newly created web page criterion.</returns> private static BiddableAdGroupCriterion AddWebPageCriteria(AdWordsUser user, long adGroupId) { using (AdGroupCriterionService adGroupCriterionService = (AdGroupCriterionService) user.GetService(AdWordsService.v201809 .AdGroupCriterionService)) { // Create a webpage criterion for special offers for mars cruise. WebpageParameter param = new WebpageParameter { criterionName = "Special offers for mars" }; WebpageCondition urlCondition = new WebpageCondition { operand = WebpageConditionOperand.URL, argument = "/marscruise/special" }; WebpageCondition titleCondition = new WebpageCondition { operand = WebpageConditionOperand.PAGE_TITLE, argument = "Special Offer" }; param.conditions = new WebpageCondition[] { urlCondition, titleCondition }; Webpage webpage = new Webpage { parameter = param }; // Create biddable ad group criterion. BiddableAdGroupCriterion biddableAdGroupCriterion = new BiddableAdGroupCriterion { adGroupId = adGroupId, criterion = webpage, userStatus = UserStatus.PAUSED }; // Optional: set a custom bid. BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration(); CpcBid bid = new CpcBid() { bid = new Money() { microAmount = 10000000L } }; biddingStrategyConfiguration.bids = new Bids[] { bid }; biddableAdGroupCriterion.biddingStrategyConfiguration = biddingStrategyConfiguration; // Create the operation. AdGroupCriterionOperation operation = new AdGroupCriterionOperation { @operator = Operator.ADD, operand = biddableAdGroupCriterion }; try { AdGroupCriterionReturnValue result = adGroupCriterionService.mutate( new AdGroupCriterionOperation[] { operation }); BiddableAdGroupCriterion newCriterion = (BiddableAdGroupCriterion) result.value[0]; Console.WriteLine( "Webpage criterion with ID = '{0}' was added to ad group ID '{1}'.", newCriterion.criterion.id, newCriterion.adGroupId); return newCriterion; } catch (Exception e) { throw new System.ApplicationException("Failed to create webpage criterion.", e); } } } } }
Add an expanded text ad with Upgraded URLs
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; using System.Collections.Generic; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds an expanded text ad that uses advanced features /// of upgraded URLs. /// </summary> public class AddExpandedTextAdWithUpgradedUrls : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddExpandedTextAdWithUpgradedUrls codeExample = new AddExpandedTextAdWithUpgradedUrls(); Console.WriteLine(codeExample.Description); try { long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE"); codeExample.Run(new AdWordsUser(), adGroupId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds an expanded text ad that uses advanced features of " + "upgraded URLs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">ID of the ad group to which ad is added. /// </param> public void Run(AdWordsUser user, long adGroupId) { using (AdGroupAdService adGroupAdService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { // Create the expanded text ad. ExpandedTextAd expandedTextAd = new ExpandedTextAd() { headlinePart1 = "Luxury Cruise to Mars", headlinePart2 = "Visit the Red Planet in style.", description = "Low-gravity fun for everyone!", }; // Specify a tracking URL for 3rd party tracking provider. You may // specify one at customer, campaign, ad group, ad, criterion or // feed item levels. expandedTextAd.trackingUrlTemplate = "http://tracker.example.com/?season={_season}&promocode={_promocode}&u={lpurl}"; // Since your tracking URL has two custom parameters, provide their // values too. This can be provided at campaign, ad group, ad, criterion // or feed item levels. CustomParameter seasonParameter = new CustomParameter { key = "season", value = "christmas" }; CustomParameter promoCodeParameter = new CustomParameter { key = "promocode", value = "NYC123" }; expandedTextAd.urlCustomParameters = new CustomParameters { parameters = new CustomParameter[] { seasonParameter, promoCodeParameter } }; // Specify a list of final URLs. This field cannot be set if URL field is // set. This may be specified at ad, criterion and feed item levels. expandedTextAd.finalUrls = new string[] { "http://www.example.com/cruise/space/", "http://www.example.com/locations/mars/" }; // Specify a list of final mobile URLs. This field cannot be set if URL // field is set, or finalUrls is unset. This may be specified at ad, // criterion and feed item levels. expandedTextAd.finalMobileUrls = new string[] { "http://mobile.example.com/cruise/space/", "http://mobile.example.com/locations/mars/" }; AdGroupAd adGroupAd = new AdGroupAd { adGroupId = adGroupId, ad = expandedTextAd, // Optional: Set the status. status = AdGroupAdStatus.PAUSED }; // Create the operation. AdGroupAdOperation operation = new AdGroupAdOperation { @operator = Operator.ADD, operand = adGroupAd }; AdGroupAdReturnValue retVal = null; try { // Create the ads. retVal = adGroupAdService.mutate(new AdGroupAdOperation[] { operation }); // Display the results. if (retVal != null && retVal.value != null) { ExpandedTextAd newExpandedTextAd = retVal.value[0].ad as ExpandedTextAd; Console.WriteLine( "Expanded text ad with ID '{0}' and headline '{1} - {2}' was added.", newExpandedTextAd.id, newExpandedTextAd.headlinePart1, newExpandedTextAd.headlinePart2); Console.WriteLine("Upgraded URL properties:"); Console.WriteLine(" Final URLs: {0}", string.Join(", ", newExpandedTextAd.finalUrls)); Console.WriteLine(" Final Mobile URLs: {0}", string.Join(", ", newExpandedTextAd.finalMobileUrls)); Console.WriteLine(" Tracking URL template: {0}", newExpandedTextAd.trackingUrlTemplate); List<string> parameters = new List<string>(); foreach (CustomParameter customParam in newExpandedTextAd .urlCustomParameters.parameters) { parameters.Add(string.Format("{0}={1}", customParam.key, customParam.value)); } Console.WriteLine(" Custom parameters: {0}", string.Join(", ", parameters.ToArray())); } else { Console.WriteLine("No expanded text ads were created."); } } catch (Exception e) { throw new System.ApplicationException("Failed to create expanded text ad.", e); } } } } }
Add a Gmail ad to an ad group
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using Google.Api.Ads.Common.Util; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds a Gmail ad to a given ad group. The ad group's /// campaign needs to have an AdvertisingChannelType of DISPLAY and /// AdvertisingChannelSubType of DISPLAY_GMAIL_AD. /// To get ad groups, run GetAdGroups.cs. /// </summary> public class AddGmailAd : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddGmailAd codeExample = new AddGmailAd(); Console.WriteLine(codeExample.Description); try { long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE"); codeExample.Run(new AdWordsUser(), adGroupId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds a Gmail ad to a given ad group. The ad group's " + "campaign needs to have an AdvertisingChannelType of DISPLAY and " + "AdvertisingChannelSubType of DISPLAY_GMAIL_AD. To get ad groups, " + "run GetAdGroups.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Id of the adgroup to which ads are added.</param> public void Run(AdWordsUser user, long adGroupId) { using (AdGroupAdService adGroupAdService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { // This ad format does not allow the creation of an image using the // Image.data field. An image must first be created using the // MediaService, and Image.mediaId must be populated when creating the // ad. Image logoImage = new Image { mediaId = UploadImage(user, "https://goo.gl/mtt54n").mediaId }; Image marketingImage = new Image { mediaId = UploadImage(user, "https://goo.gl/3b9Wfh").mediaId }; GmailTeaser teaser = new GmailTeaser { headline = "Dream", description = "Create your own adventure", businessName = "Interplanetary Ships", logoImage = logoImage }; // Creates a Gmail ad. GmailAd gmailAd = new GmailAd { teaser = teaser, marketingImage = marketingImage, marketingImageHeadline = "Travel", marketingImageDescription = "Take to the skies!", finalUrls = new string[] { "http://www.example.com/" } }; // Creates ad group ad for the Gmail ad. AdGroupAd adGroupAd = new AdGroupAd { adGroupId = adGroupId, ad = gmailAd, // Optional: Set additional settings. status = AdGroupAdStatus.PAUSED }; // Creates ad group ad operation and add it to the list. AdGroupAdOperation operation = new AdGroupAdOperation { operand = adGroupAd, @operator = Operator.ADD }; try { // Adds a responsive display ad on the server. AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[] { operation }); if (result == null || result.value == null || result.value.Length == 0) { Console.WriteLine("No Gmail ads were added."); return; } // Prints out some information for each created Gmail ad. foreach (AdGroupAd newAdGroupAd in result.value) { Console.WriteLine("A Gmail ad with ID {0} and headline '{1}' was added.", newAdGroupAd.ad.id, (newAdGroupAd.ad as GmailAd).teaser.headline); } } catch (Exception e) { throw new System.ApplicationException("Failed to add Gmail ads.", e); } } } /// <summary> /// Uploads an image to the server. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="url">The URL of image to upload.</param> /// <returns>The created image.</returns> private static Media UploadImage(AdWordsUser user, string url) { using (MediaService mediaService = (MediaService) user.GetService(AdWordsService.v201809.MediaService)) { Image image = new Image { data = MediaUtilities.GetAssetDataFromUrl(url, user.Config), type = MediaMediaType.IMAGE }; return mediaService.upload(new Media[] { image })[0]; } } } }
Add an HTML 5 ad to an ad group
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using Google.Api.Ads.Common.Util; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds an HTML5 ad to a given ad group. To get ad groups, /// run GetAdGroups.cs. /// </summary> public class AddHtml5Ad : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddHtml5Ad codeExample = new AddHtml5Ad(); Console.WriteLine(codeExample.Description); try { long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE"); codeExample.Run(new AdWordsUser(), adGroupId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds an HTML5 ad to a given ad group. To get ad groups," + " run GetAdGroups.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Id of the first adgroup to which ad is added.</param> public void Run(AdWordsUser user, long adGroupId) { using (AdGroupAdService adGroupAdService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { // Create the HTML5 template ad. See // https://developers.google.com/adwords/api/docs/guides/template-ads#html5_ads // for more details. TemplateAd html5Ad = new TemplateAd() { name = "Ad for HTML5", templateId = 419, finalUrls = new string[] { "http://example.com/html5" }, displayUrl = "www.example.com/html5", dimensions = new Dimensions() { width = 300, height = 250 } }; // The HTML5 zip file contains all the HTML, CSS, and images needed for the // HTML5 ad. For help on creating an HTML5 zip file, check out Google Web // Designer (https://www.google.com/webdesigner/). byte[] html5Zip = MediaUtilities.GetAssetDataFromUrl("https://goo.gl/9Y7qI2", user.Config); // Create a media bundle containing the zip file with all the HTML5 components. MediaBundle mediaBundle = new MediaBundle() { // You may also upload an HTML5 zip using MediaService.upload() method // set the mediaId field. See UploadMediaBundle.cs for an example on // how to upload HTML5 zip files. data = html5Zip, entryPoint = "carousel/index.html", type = MediaMediaType.MEDIA_BUNDLE }; // Create the template elements for the ad. You can refer to // https://developers.google.com/adwords/api/docs/appendix/templateads // for the list of available template fields. html5Ad.templateElements = new TemplateElement[] { new TemplateElement() { uniqueName = "adData", fields = new TemplateElementField[] { new TemplateElementField() { name = "Custom_layout", fieldMedia = mediaBundle, type = TemplateElementFieldType.MEDIA_BUNDLE }, new TemplateElementField() { name = "layout", fieldText = "Custom", type = TemplateElementFieldType.ENUM }, }, } }; // Create the AdGroupAd. AdGroupAd html5AdGroupAd = new AdGroupAd() { adGroupId = adGroupId, ad = html5Ad, // Additional properties (non-required). status = AdGroupAdStatus.PAUSED }; AdGroupAdOperation adGroupAdOperation = new AdGroupAdOperation() { @operator = Operator.ADD, operand = html5AdGroupAd }; try { // Add HTML5 ad. AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[] { adGroupAdOperation }); // Display results. if (result != null && result.value != null && result.value.Length > 0) { foreach (AdGroupAd adGroupAd in result.value) { Console.WriteLine( "New HTML5 ad with id \"{0}\" and display url \"{1}\" was added.", adGroupAd.ad.id, adGroupAd.ad.displayUrl); } } else { Console.WriteLine("No HTML5 ads were added."); } } catch (Exception e) { throw new System.ApplicationException("Failed to create HTML5 ad.", e); } } } } }
Add a multi-asset responsive display ad to an ad group
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using Google.Api.Ads.Common.Util; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds a responsive display ad (MultiAssetResponsiveDisplayAd) /// to an ad group. Image assets are uploaded using AssetService. To get ad groups, /// run GetAdGroups.cs. /// </summary> public class AddMultiAssetResponsiveDisplayAd : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddMultiAssetResponsiveDisplayAd codeExample = new AddMultiAssetResponsiveDisplayAd(); Console.WriteLine(codeExample.Description); try { long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE"); codeExample.Run(new AdWordsUser(), adGroupId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds a responsive display ad " + "(MultiAssetResponsiveDisplayAd) to an ad group. Image assets are uploaded " + "using AssetService. To get ad groups, run GetAdGroups.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Id of the ad group to which ads are added. /// </param> public void Run(AdWordsUser user, long adGroupId) { using (AdGroupAdService adGroupAdService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { try { // Create the ad. MultiAssetResponsiveDisplayAd ad = new MultiAssetResponsiveDisplayAd() { headlines = new AssetLink[] { new AssetLink() { // Text assets can be specified directly in the asset field when // creating the ad. asset = new TextAsset() { assetText = "Travel to Mars", }, }, new AssetLink() { asset = new TextAsset() { assetText = "Travel to Jupiter", }, }, new AssetLink() { asset = new TextAsset() { assetText = "Travel to Pluto", }, }, }, descriptions = new AssetLink[] { new AssetLink() { asset = new TextAsset() { assetText = "Visit the planet in a luxury spaceship.", }, }, new AssetLink() { asset = new TextAsset() { assetText = "See the planet in style.", }, }, }, businessName = "Galactic Luxury Cruises", longHeadline = new AssetLink() { asset = new TextAsset() { assetText = "Visit the planet in a luxury spaceship.", }, }, // This ad format does not allow the creation of an image asset by setting // the asset.imageData field. An image asset must first be created using the // AssetService, and asset.assetId must be populated when creating the ad. marketingImages = new AssetLink[] { new AssetLink() { asset = new ImageAsset() { assetId = UploadImageAsset(user, "https://goo.gl/3b9Wfh") }, } }, squareMarketingImages = new AssetLink[] { new AssetLink() { asset = new ImageAsset() { assetId = UploadImageAsset(user, "https://goo.gl/mtt54n") }, } }, finalUrls = new string[] { "http://www.example.com" }, // Optional: set call to action text. callToActionText = "Shop Now", // Set color settings using hexadecimal values. Set allowFlexibleColor to // false if you want your ads to render by always using your colors // strictly. mainColor = "#0000ff", accentColor = "#ffff00", allowFlexibleColor = false, // Set the format setting that the ad will be served in. formatSetting = DisplayAdFormatSetting.NON_NATIVE, // Optional: Set dynamic display ad settings, composed of landscape logo // image, promotion text, and price prefix. dynamicSettingsPricePrefix = "as low as", dynamicSettingsPromoText = "Free shipping!", logoImages = new AssetLink[] { new AssetLink() { asset = new ImageAsset() { assetId = UploadImageAsset(user, "https://goo.gl/mtt54n") }, } } }; // Create the ad group ad. AdGroupAd adGroupAd = new AdGroupAd() { ad = ad, adGroupId = adGroupId }; // Create the operation. AdGroupAdOperation operation = new AdGroupAdOperation() { operand = adGroupAd, @operator = Operator.ADD }; // Make the mutate request. AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[] { operation }); // Display results. if (result != null && result.value != null) { foreach (AdGroupAd newAdGroupAd in result.value) { MultiAssetResponsiveDisplayAd newAd = newAdGroupAd.ad as MultiAssetResponsiveDisplayAd; Console.WriteLine( "Responsive display ad with ID '{0}' and long headline '{1}'" + " was added.", newAd.id, (newAd.longHeadline.asset as TextAsset).assetText); } } else { Console.WriteLine("No responsive display ads were created."); } } catch (Exception e) { throw new System.ApplicationException("Failed to create responsive display ad.", e); } } } /// <summary> /// Uploads the image from the specified <paramref name="url"/>. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="url">The image URL.</param> /// <returns>ID of the uploaded image.</returns> private static long UploadImageAsset(AdWordsUser user, string url) { using (AssetService assetService = (AssetService) user.GetService(AdWordsService.v201809.AssetService)) { // Create the image asset. ImageAsset imageAsset = new ImageAsset() { // Optional: Provide a unique friendly name to identify your asset. If you // specify the assetName field, then both the asset name and the image being // uploaded should be unique, and should not match another ACTIVE asset in this // customer account. // assetName = "Image asset " + ExampleUtilities.GetRandomString(), imageData = MediaUtilities.GetAssetDataFromUrl(url, user.Config), }; // Create the operation. AssetOperation operation = new AssetOperation() { @operator = Operator.ADD, operand = imageAsset }; // Create the asset and return the ID. return assetService.mutate(new AssetOperation[] { operation }).value[0].assetId; } } } }
Add a responsive display ad
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using Google.Api.Ads.Common.Util; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds an image representing the ad using the MediaService /// and then adds a responsive display ad to an ad group. To get ad groups, /// run GetAdGroups.cs. /// </summary> public class AddResponsiveDisplayAd : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddResponsiveDisplayAd codeExample = new AddResponsiveDisplayAd(); Console.WriteLine(codeExample.Description); try { long adGroupId = long.Parse("INSERT_ADGROUP_ID_HERE"); codeExample.Run(new AdWordsUser(), adGroupId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds an image representing the ad using the MediaService " + "and then adds a responsive display ad to an ad group. To get ad groups, " + "run GetAdGroups.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Id of the ad group to which ads are added. /// </param> public void Run(AdWordsUser user, long adGroupId) { using (AdGroupAdService adGroupAdService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { try { // Create a responsive display ad. ResponsiveDisplayAd responsiveDisplayAd = new ResponsiveDisplayAd { // This ad format does not allow the creation of an image using the // Image.data field. An image must first be created using the MediaService, // and Image.mediaId must be populated when creating the ad. marketingImage = new Image() { mediaId = UploadImage(user, "https://goo.gl/3b9Wfh") }, shortHeadline = "Travel", longHeadline = "Travel the World", description = "Take to the air!", businessName = "Google", finalUrls = new string[] { "http://www.example.com" }, // Optional: Create a square marketing image using MediaService, and set it // to the ad. squareMarketingImage = new Image() { mediaId = UploadImage(user, "https://goo.gl/mtt54n"), }, // Optional: set call to action text. callToActionText = "Shop Now", // Optional: Set dynamic display ad settings, composed of landscape logo // image, promotion text, and price prefix. dynamicDisplayAdSettings = CreateDynamicDisplayAdSettings(user) }; // Whitelisted accounts only: Set color settings using hexadecimal values. // Set allowFlexibleColor to false if you want your ads to render by always // using your colors strictly. // responsiveDisplayAd.mainColor = "#0000ff"; // responsiveDisplayAd.accentColor = "#ffff00"; // responsiveDisplayAd.allowFlexibleColor = false; // Whitelisted accounts only: Set the format setting that the ad will be // served in. // responsiveDisplayAd.formatSetting = DisplayAdFormatSetting.NON_NATIVE; // Create ad group ad. AdGroupAd adGroupAd = new AdGroupAd() { adGroupId = adGroupId, ad = responsiveDisplayAd, status = AdGroupAdStatus.PAUSED }; // Create operation. AdGroupAdOperation operation = new AdGroupAdOperation() { operand = adGroupAd, @operator = Operator.ADD }; // Make the mutate request. AdGroupAdReturnValue result = adGroupAdService.mutate(new AdGroupAdOperation[] { operation }); // Display results. if (result != null && result.value != null) { foreach (AdGroupAd newAdGroupAd in result.value) { ResponsiveDisplayAd newAd = newAdGroupAd.ad as ResponsiveDisplayAd; Console.WriteLine( "Responsive display ad with ID '{0}' and short headline '{1}'" + " was added.", newAd.id, newAd.shortHeadline); } } else { Console.WriteLine("No responsive display ads were created."); } } catch (Exception e) { throw new System.ApplicationException("Failed to create responsive display ad.", e); } } } /// <summary> /// Creates the dynamic display ad settings. /// </summary> /// <param name="user">The AdWords user.</param> /// <returns></returns> private static DynamicSettings CreateDynamicDisplayAdSettings(AdWordsUser user) { long logoImageMediaId = UploadImage(user, "https://goo.gl/dEvQeF"); Image logo = new Image() { mediaId = logoImageMediaId }; return new DynamicSettings() { landscapeLogoImage = logo, pricePrefix = "as low as", promoText = "Free shipping!" }; } /// <summary> /// Uploads the image from the specified <paramref name="url"/>. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="url">The image URL.</param> /// <returns>ID of the uploaded image.</returns> private static long UploadImage(AdWordsUser user, string url) { using (MediaService mediaService = (MediaService) user.GetService(AdWordsService.v201809.MediaService)) { // Create the image. Image image = new Image() { data = MediaUtilities.GetAssetDataFromUrl(url, user.Config), type = MediaMediaType.IMAGE }; // Upload the image and return the ID. return mediaService.upload(new Media[] { image })[0].mediaId; } } } }
Add a Shopping dynamic remarketing campaign
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using Google.Api.Ads.Common.Util; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds a Shopping dynamic remarketing campaign for the Display Network /// via the following steps: /// <list type="bullet"> /// <item> /// <description>Creates a new Display Network campaign.</description> /// </item> /// <item> /// <description>Links the campaign with Merchant Center.</description> /// </item> /// <item> /// <description>Links the user list to the ad group.</description> /// </item> /// <item> /// <description>Creates a responsive display ad to render the dynamic text.</description> /// </item> /// </list> /// </summary> public class AddShoppingDynamicRemarketingCampaign : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddShoppingDynamicRemarketingCampaign codeExample = new AddShoppingDynamicRemarketingCampaign(); Console.WriteLine(codeExample.Description); try { // The ID of the merchant center account from which to source product feed data. long merchantId = long.Parse("INSERT_MERCHANT_CENTER_ID_HERE"); // The ID of a shared budget to associate with the campaign. long budgetId = long.Parse("INSERT_BUDGET_ID_HERE"); // The ID of a user list to target. long userListId = long.Parse("INSERT_USER_LIST_ID_HERE"); codeExample.Run(new AdWordsUser(), merchantId, budgetId, userListId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds a Shopping dynamic remarketing campaign for the " + "Display Network via the following steps:\n" + "* Creates a new Display Network campaign.\n" + "* Links the campaign with Merchant Center.\n" + "* Links the user list to the ad group.\n" + "* Creates a responsive display ad to render the dynamic text."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="merchantId">The ID of the merchant center account from which to source /// product feed data.</param> /// <param name="budgetId">The ID of a shared budget to associate with the campaign.</param> /// <param name="userListId">The ID of a user list to target.</param> public void Run(AdWordsUser user, long merchantId, long budgetId, long userListId) { try { Campaign campaign = CreateCampaign(user, merchantId, budgetId); Console.WriteLine("Campaign with name '{0}' and ID {1} was added.", campaign.name, campaign.id); AdGroup adGroup = CreateAdGroup(user, campaign); Console.WriteLine("Ad group with name '{0}' and ID {1} was added.", adGroup.name, adGroup.id); AdGroupAd adGroupAd = CreateAd(user, adGroup); Console.WriteLine("Responsive display ad with ID {0} was added.", adGroupAd.ad.id); AttachUserList(user, adGroup, userListId); Console.WriteLine("User list with ID {0} was attached to ad group with ID {1}.", userListId, adGroup.id); } catch (Exception e) { throw new System.ApplicationException( "Failed to create Shopping dynamic remarketing " + "campaign for the Display Network.", e); } } /// <summary> /// Creates a Shopping dynamic remarketing campaign object (not including ad group level and /// below). This creates a Display campaign with the merchant center feed attached. /// Merchant Center is used for the product information in combination with a user list /// which contains hits with <code>ecomm_prodid</code> specified. See /// <a href="https://developers.google.com/adwords-remarketing-tag/parameters#retail"> /// the guide</a> for more detail. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="merchantId">The ID of the Merchant Center account.</param> /// <param name="budgetId">The ID of the budget to use for the campaign.</param> /// <returns>The campaign that was created.</returns> private static Campaign CreateCampaign(AdWordsUser user, long merchantId, long budgetId) { using (CampaignService campaignService = (CampaignService) user.GetService(AdWordsService.v201809.CampaignService)) { Campaign campaign = new Campaign { name = "Shopping campaign #" + ExampleUtilities.GetRandomString(), // Dynamic remarketing campaigns are only available on the Google Display // Network. advertisingChannelType = AdvertisingChannelType.DISPLAY, status = CampaignStatus.PAUSED }; Budget budget = new Budget { budgetId = budgetId }; campaign.budget = budget; // This example uses a Manual CPC bidding strategy, but you should select the // strategy that best aligns with your sales goals. More details here: // https://support.google.com/adwords/answer/2472725 BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration { biddingStrategyType = BiddingStrategyType.MANUAL_CPC }; campaign.biddingStrategyConfiguration = biddingStrategyConfiguration; ShoppingSetting setting = new ShoppingSetting { // Campaigns with numerically higher priorities take precedence over those with // lower priorities. campaignPriority = 0, // Set the Merchant Center account ID from which to source products. merchantId = merchantId, // Display Network campaigns do not support partition by country. The only // supported value is "ZZ". This signals that products from all countries are // available in the campaign. The actual products which serve are based on the // products tagged in the user list entry. salesCountry = "ZZ", // Optional: Enable local inventory ads (items for sale in physical stores.) enableLocal = true }; campaign.settings = new Setting[] { setting }; CampaignOperation op = new CampaignOperation { operand = campaign, @operator = Operator.ADD }; CampaignReturnValue result = campaignService.mutate(new CampaignOperation[] { op }); return result.value[0]; } } /// <summary> /// Creates an ad group in the specified campaign. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaign">The campaign to which the ad group should be attached.</param> /// <returns>The ad group that was created.</returns> private static AdGroup CreateAdGroup(AdWordsUser user, Campaign campaign) { using (AdGroupService adGroupService = (AdGroupService) user.GetService(AdWordsService.v201809.AdGroupService)) { AdGroup group = new AdGroup { name = "Dynamic remarketing ad group", campaignId = campaign.id, status = AdGroupStatus.ENABLED }; AdGroupOperation op = new AdGroupOperation { operand = group, @operator = Operator.ADD }; AdGroupReturnValue result = adGroupService.mutate(new AdGroupOperation[] { op }); return result.value[0]; } } /// <summary> /// Attach a user list to an ad group. The user list provides positive targeting and feed /// information to drive the dynamic content of the ad. /// </summary> /// <param name="user">The user.</param> /// <param name="adGroup">The ad group which will have the user list attached.</param> /// <param name="userListId">The user list to use for targeting and dynamic content.</param> /// <remarks>User lists must be attached at the ad group level for positive targeting in /// Shopping dynamic remarketing campaigns.</remarks> private static void AttachUserList(AdWordsUser user, AdGroup adGroup, long userListId) { using (AdGroupCriterionService adGroupCriterionService = (AdGroupCriterionService) user.GetService(AdWordsService.v201809 .AdGroupCriterionService)) { CriterionUserList userList = new CriterionUserList { userListId = userListId }; BiddableAdGroupCriterion adGroupCriterion = new BiddableAdGroupCriterion { criterion = userList, adGroupId = adGroup.id }; AdGroupCriterionOperation op = new AdGroupCriterionOperation { operand = adGroupCriterion, @operator = Operator.ADD }; adGroupCriterionService.mutate(new AdGroupCriterionOperation[] { op }); } } /// <summary> /// Creates an ad for serving dynamic content in a remarketing campaign. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroup">The ad group under which to create the ad.</param> /// <returns>The ad that was created.</returns> private static AdGroupAd CreateAd(AdWordsUser user, AdGroup adGroup) { using (AdGroupAdService adService = (AdGroupAdService) user.GetService(AdWordsService.v201809.AdGroupAdService)) { ResponsiveDisplayAd ad = new ResponsiveDisplayAd { // This ad format does not allow the creation of an image using the // Image.data field. An image must first be created using the MediaService, // and Image.mediaId must be populated when creating the ad. marketingImage = UploadImage(user, "https://goo.gl/3b9Wfh"), shortHeadline = "Travel", longHeadline = "Travel the World", description = "Take to the air!", businessName = "Interplanetary Cruises", finalUrls = new string[] { "http://www.example.com/" }, // Optional: Call to action text. // Valid texts: https://support.google.com/adwords/answer/7005917 callToActionText = "Apply Now", // Optional: Set dynamic display ad settings, composed of landscape logo // image, promotion text, and price prefix. dynamicDisplayAdSettings = CreateDynamicDisplayAdSettings(user), // Optional: Create a logo image and set it to the ad. logoImage = UploadImage(user, "https://goo.gl/mtt54n"), // Optional: Create a square marketing image and set it to the ad. squareMarketingImage = UploadImage(user, "https://goo.gl/mtt54n") }; // Whitelisted accounts only: Set color settings using hexadecimal values. // Set allowFlexibleColor to false if you want your ads to render by always // using your colors strictly. // ad.mainColor = "#0000ff"; // ad.accentColor = "#ffff00"; // ad.allowFlexibleColor = false; // Whitelisted accounts only: Set the format setting that the ad will be // served in. // ad.formatSetting = DisplayAdFormatSetting.NON_NATIVE; AdGroupAd adGroupAd = new AdGroupAd { ad = ad, adGroupId = adGroup.id }; AdGroupAdOperation op = new AdGroupAdOperation { operand = adGroupAd, @operator = Operator.ADD }; AdGroupAdReturnValue result = adService.mutate(new AdGroupAdOperation[] { op }); return result.value[0]; } } /// <summary> /// Creates the additional content (images, promo text, etc.) supported by dynamic ads. /// </summary> /// <param name="user">The AdWords user.</param> /// <returns>The DynamicSettings object to be used.</returns> private static DynamicSettings CreateDynamicDisplayAdSettings(AdWordsUser user) { Image logo = UploadImage(user, "https://goo.gl/dEvQeF"); DynamicSettings dynamicSettings = new DynamicSettings { landscapeLogoImage = logo, pricePrefix = "as low as", promoText = "Free shipping!" }; return dynamicSettings; } /// <summary> /// Uploads the image from the specified <paramref name="url"/>. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="url">The image URL.</param> /// <returns>ID of the uploaded image.</returns> private static Image UploadImage(AdWordsUser user, string url) { using (MediaService mediaService = (MediaService) user.GetService(AdWordsService.v201809.MediaService)) { // Create the image. Image image = new Image() { data = MediaUtilities.GetAssetDataFromUrl(url, user.Config), type = MediaMediaType.IMAGE }; // Upload the image and return the ID. return (Image) mediaService.upload(new Media[] { image })[0]; } } } }
Add a universal app campaign
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; using System.Collections.Generic; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds a universal app campaign. To get campaigns, run GetCampaigns.cs. /// To upload image assets for this campaign, use UploadImage.cs. /// </summary> public class AddUniversalAppCampaign : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { AddUniversalAppCampaign codeExample = new AddUniversalAppCampaign(); Console.WriteLine(codeExample.Description); try { codeExample.Run(new AdWordsUser()); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds a universal app campaign. To get campaigns, " + "run GetCampaigns.cs. To upload image assets for this campaign, " + "use UploadImage.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> public void Run(AdWordsUser user) { using (CampaignService campaignService = (CampaignService) user.GetService(AdWordsService.v201809.CampaignService)) { // Create the campaign. Campaign campaign = new Campaign { name = "Interplanetary Cruise App #" + ExampleUtilities.GetRandomString(), // 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. status = CampaignStatus.PAUSED, // Set the advertising channel and subchannel types for universal app campaigns. advertisingChannelType = AdvertisingChannelType.MULTI_CHANNEL, advertisingChannelSubType = AdvertisingChannelSubType.UNIVERSAL_APP_CAMPAIGN }; // Set the campaign's bidding strategy. Universal app campaigns // only support TARGET_CPA bidding strategy. BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration { biddingStrategyType = BiddingStrategyType.TARGET_CPA }; // Set the target CPA to $1 / app install. TargetCpaBiddingScheme biddingScheme = new TargetCpaBiddingScheme { targetCpa = new Money { microAmount = 1000000 } }; biddingConfig.biddingScheme = biddingScheme; campaign.biddingStrategyConfiguration = biddingConfig; // Set the campaign's budget. campaign.budget = new Budget { budgetId = CreateBudget(user).budgetId }; // Optional: Set the start date. campaign.startDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd"); // Optional: Set the end date. campaign.endDate = DateTime.Now.AddYears(1).ToString("yyyyMMdd"); // Set the campaign's assets and ad text ideas. These values will be used to // generate ads. UniversalAppCampaignSetting universalAppSetting = new UniversalAppCampaignSetting { appId = "com.labpixies.colordrips", appVendor = MobileApplicationVendor.VENDOR_GOOGLE_MARKET, description1 = "A cool puzzle game", description2 = "Remove connected blocks", description3 = "3 difficulty levels", description4 = "4 colorful fun skins", // Optional: You can set up to 20 image assets for your campaign. // See UploadImage.cs for an example on how to upload images. // // universalAppSetting.imageMediaIds = // new long[] { INSERT_IMAGE_MEDIA_ID_HERE }; // Optimize this campaign for getting new users for your app. universalAppBiddingStrategyGoalType = UniversalAppBiddingStrategyGoalType .OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME }; // Optional: If you select the OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME goal // type, then also specify your in-app conversion types so AdWords can // focus your campaign on people who are most likely to complete the // corresponding in-app actions. // Conversion type IDs can be retrieved using ConversionTrackerService.get. // // campaign.selectiveOptimization = new SelectiveOptimization(); // campaign.selectiveOptimization.conversionTypeIds = new long[] // { // INSERT_CONVERSION_TYPE_ID_1_HERE, // INSERT_CONVERSION_TYPE_ID_2_HERE // }; // Optional: Set the campaign settings for Advanced location options. GeoTargetTypeSetting geoSetting = new GeoTargetTypeSetting { positiveGeoTargetType = GeoTargetTypeSettingPositiveGeoTargetType.LOCATION_OF_PRESENCE, negativeGeoTargetType = GeoTargetTypeSettingNegativeGeoTargetType.DONT_CARE }; campaign.settings = new Setting[] { universalAppSetting, geoSetting }; // Create the operation. CampaignOperation operation = new CampaignOperation { @operator = Operator.ADD, operand = campaign }; try { // Add the campaign. CampaignReturnValue retVal = campaignService.mutate(new CampaignOperation[] { operation }); // Display the results. if (retVal != null && retVal.value != null && retVal.value.Length > 0) { foreach (Campaign newCampaign in retVal.value) { Console.WriteLine( "Universal app campaign with name = '{0}' and id = '{1}' " + "was added.", newCampaign.name, newCampaign.id); // Optional: Set the campaign's location and language targeting. // No other targeting criteria can be used for universal app campaigns. SetCampaignTargetingCriteria(user, newCampaign); } } else { Console.WriteLine("No universal app campaigns were added."); } } catch (Exception e) { throw new System.ApplicationException("Failed to add universal app campaigns.", e); } } } /// <summary> /// Creates the budget for the campaign. /// </summary> /// <param name="user">The AdWords user.</param> /// <returns>The budget.</returns> private Budget CreateBudget(AdWordsUser user) { // Get the BudgetService. using (BudgetService budgetService = (BudgetService) user.GetService(AdWordsService.v201809.BudgetService)) { // Create the campaign budget. Budget budget = new Budget { name = "Interplanetary Cruise App Budget #" + ExampleUtilities.GetRandomString(), deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD, amount = new Money { microAmount = 5000000 }, // Universal app campaigns don't support shared budgets. isExplicitlyShared = false }; BudgetOperation budgetOperation = new BudgetOperation { @operator = Operator.ADD, operand = budget }; BudgetReturnValue budgetRetval = budgetService.mutate(new BudgetOperation[] { budgetOperation }); Budget newBudget = budgetRetval.value[0]; Console.WriteLine("Budget with ID = '{0}' and name = '{1}' was created.", newBudget.budgetId, newBudget.name); return newBudget; } } /// <summary> /// Sets the campaign's targeting criteria. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaign">The campaign for which targeting criteria is /// created.</param> private void SetCampaignTargetingCriteria(AdWordsUser user, Campaign campaign) { using (CampaignCriterionService campaignCriterionService = (CampaignCriterionService) user.GetService(AdWordsService.v201809 .CampaignCriterionService)) { // Create locations. The IDs can be found in the documentation or // retrieved with the LocationCriterionService. Location california = new Location() { id = 21137L }; Location mexico = new Location() { id = 2484L }; // Create languages. The IDs can be found in the documentation or // retrieved with the ConstantDataService. Language english = new Language() { id = 1000L }; Language spanish = new Language() { id = 1003L }; List<Criterion> criteria = new List<Criterion>() { california, mexico, english, spanish }; // Create operations to add each of the criteria above. List<CampaignCriterionOperation> operations = new List<CampaignCriterionOperation>(); foreach (Criterion criterion in criteria) { CampaignCriterionOperation operation = new CampaignCriterionOperation() { operand = new CampaignCriterion() { campaignId = campaign.id, criterion = criterion }, @operator = Operator.ADD }; operations.Add(operation); } // Set the campaign targets. CampaignCriterionReturnValue retVal = campaignCriterionService.mutate(operations.ToArray()); if (retVal != null && retVal.value != null) { // Display the added campaign targets. foreach (CampaignCriterion criterion in retVal.value) { Console.WriteLine("Campaign criteria of type '{0}' and id '{1}' was added.", criterion.criterion.CriterionType, criterion.criterion.id); } } } } } }
Create a negative broad match keywords list and attach it to a campaign
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; using System.Collections.Generic; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example creates a shared keyword list, adds keywords to the list /// and attaches it to an existing campaign. To get the list of campaigns, /// run GetCampaigns.cs. /// </summary> public class CreateAndAttachSharedKeywordSet : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { CreateAndAttachSharedKeywordSet codeExample = new CreateAndAttachSharedKeywordSet(); Console.WriteLine(codeExample.Description); try { long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE"); codeExample.Run(new AdWordsUser(), campaignId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example creates a shared keyword list, adds keywords to the list " + "and attaches it to an existing campaign. To get the list of campaigns, run " + "GetCampaigns.cs."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">Id of the campaign to which keywords are added.</param> public void Run(AdWordsUser user, long campaignId) { try { // Create a shared set. SharedSet sharedSet = CreateSharedKeywordSet(user); Console.WriteLine( "Shared set with id = {0}, name = {1}, type = {2}, status = {3} " + "was created.", sharedSet.sharedSetId, sharedSet.name, sharedSet.type, sharedSet.status); // Add new keywords to the shared set. string[] keywordTexts = new string[] { "mars cruise", "mars hotels" }; SharedCriterion[] sharedCriteria = AddKeywordsToSharedSet(user, sharedSet.sharedSetId, keywordTexts); foreach (SharedCriterion sharedCriterion in sharedCriteria) { Keyword keyword = sharedCriterion.criterion as Keyword; Console.WriteLine( "Added keyword with id = {0}, text = {1}, matchtype = {2} to " + "shared set with id = {3}.", keyword.id, keyword.text, keyword.matchType, sharedSet.sharedSetId); } // Attach the shared set to the campaign. CampaignSharedSet attachedSharedSet = AttachSharedSetToCampaign(user, campaignId, sharedSet.sharedSetId); Console.WriteLine("Attached shared set with id = {0} to campaign id {1}.", attachedSharedSet.sharedSetId, attachedSharedSet.campaignId); } catch (Exception e) { throw new System.ApplicationException( "Failed to create shared keyword set and attach " + "it to a campaign.", e); } } /// <summary> /// Create a shared keyword set. /// </summary> /// <param name="user">The AdWords user.</param> /// <returns>The shared set.</returns> public SharedSet CreateSharedKeywordSet(AdWordsUser user) { using (SharedSetService sharedSetService = (SharedSetService) user.GetService(AdWordsService.v201809.SharedSetService)) { SharedSetOperation operation = new SharedSetOperation { @operator = Operator.ADD }; SharedSet sharedSet = new SharedSet { name = "API Negative keyword list - " + ExampleUtilities.GetRandomString(), type = SharedSetType.NEGATIVE_KEYWORDS }; operation.operand = sharedSet; SharedSetReturnValue retval = sharedSetService.mutate(new SharedSetOperation[] { operation }); return retval.value[0]; } } /// <summary> /// Adds a set of keywords to a shared set. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="sharedSetId">The shared set id.</param> /// <param name="keywordTexts">The keywords to be added to the shared set.</param> /// <returns>The newly added set of shared criteria.</returns> public SharedCriterion[] AddKeywordsToSharedSet(AdWordsUser user, long sharedSetId, string[] keywordTexts) { using (SharedCriterionService sharedCriterionService = (SharedCriterionService) user.GetService(AdWordsService.v201809 .SharedCriterionService)) { List<SharedCriterionOperation> operations = new List<SharedCriterionOperation>(); foreach (string keywordText in keywordTexts) { Keyword keyword = new Keyword { text = keywordText, matchType = KeywordMatchType.BROAD }; SharedCriterion sharedCriterion = new SharedCriterion { criterion = keyword, negative = true, sharedSetId = sharedSetId }; SharedCriterionOperation operation = new SharedCriterionOperation { @operator = Operator.ADD, operand = sharedCriterion }; operations.Add(operation); } SharedCriterionReturnValue retval = sharedCriterionService.mutate(operations.ToArray()); return retval.value; } } /// <summary> /// Attaches a shared set to a campaign. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">The campaign id.</param> /// <param name="sharedSetId">The shared set id.</param> /// <returns>A CampaignSharedSet object that represents a binding between /// the specified campaign and the shared set.</returns> public CampaignSharedSet AttachSharedSetToCampaign(AdWordsUser user, long campaignId, long sharedSetId) { using (CampaignSharedSetService campaignSharedSetService = (CampaignSharedSetService) user.GetService(AdWordsService.v201809 .CampaignSharedSetService)) { CampaignSharedSet campaignSharedSet = new CampaignSharedSet { campaignId = campaignId, sharedSetId = sharedSetId }; CampaignSharedSetOperation operation = new CampaignSharedSetOperation { @operator = Operator.ADD, operand = campaignSharedSet }; CampaignSharedSetReturnValue retval = campaignSharedSetService.mutate( new CampaignSharedSetOperation[] { operation }); return retval.value[0]; } } } }
Find and remove shared sets and shared set criteria
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; using System.Collections.Generic; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example demonstrates how to find and remove shared sets and /// shared set criteria. /// </summary> public class FindAndRemoveCriteriaFromSharedSet : ExampleBase { /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example demonstrates how to find and remove shared sets and " + "shared set criteria."; } } /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { FindAndRemoveCriteriaFromSharedSet codeExample = new FindAndRemoveCriteriaFromSharedSet(); Console.WriteLine(codeExample.Description); try { long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE"); codeExample.Run(new AdWordsUser(), campaignId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">Id of the campaign from which items shared /// criteria are removed.</param> public void Run(AdWordsUser user, long campaignId) { // Get the list of shared sets that are attached to the campaign. List<string> sharedSetIds = GetSharedSetIds(user, campaignId); // Get the shared criteria in those shared sets. List<SharedCriterion> sharedCriteria = GetSharedCriteria(user, sharedSetIds); // Remove the shared criteria from the shared sets. RemoveSharedCriteria(user, sharedCriteria); } /// <summary> /// Gets the shared set IDs associated with a campaign. /// </summary> /// <param name="user">The user that owns the campaign.</param> /// <param name="campaignId">The campaign identifier.</param> /// <returns>The list of shared set IDs associated with the campaign.</returns> private List<string> GetSharedSetIds(AdWordsUser user, long campaignId) { using (CampaignSharedSetService campaignSharedSetService = (CampaignSharedSetService) user.GetService(AdWordsService.v201809 .CampaignSharedSetService)) { Selector selector = new Selector() { fields = new string[] { CampaignSharedSet.Fields.SharedSetId, CampaignSharedSet.Fields.CampaignId, CampaignSharedSet.Fields.SharedSetName, CampaignSharedSet.Fields.SharedSetType }, predicates = new Predicate[] { Predicate.Equals(CampaignSharedSet.Fields.CampaignId, campaignId), Predicate.In(CampaignSharedSet.Fields.SharedSetType, new string[] { SharedSetType.NEGATIVE_KEYWORDS.ToString() }), }, paging = Paging.Default, }; List<string> sharedSetIds = new List<string>(); CampaignSharedSetPage page = new CampaignSharedSetPage(); try { do { // Get the campaigns. page = campaignSharedSetService.get(selector); // Display the results. if (page != null && page.entries != null) { int i = selector.paging.startIndex; foreach (CampaignSharedSet campaignSharedSet in page.entries) { sharedSetIds.Add(campaignSharedSet.sharedSetId.ToString()); Console.WriteLine( "{0}) Campaign shared set ID {1} and name '{2}' found for " + "campaign ID {3}.\n", i + 1, campaignSharedSet.sharedSetId, campaignSharedSet.sharedSetName, campaignSharedSet.campaignId); i++; } } selector.paging.IncreaseOffset(); } while (selector.paging.startIndex < page.totalNumEntries); return sharedSetIds; } catch (Exception e) { throw new Exception("Failed to get shared set ids for campaign.", e); } } } /// <summary> /// Gets the shared criteria in a shared set. /// </summary> /// <param name="user">The user that owns the shared set.</param> /// <param name="sharedSetIds">The shared criteria IDs.</param> /// <returns>The list of shared criteria.</returns> private List<SharedCriterion> GetSharedCriteria(AdWordsUser user, List<string> sharedSetIds) { using (SharedCriterionService sharedCriterionService = (SharedCriterionService) user.GetService(AdWordsService.v201809 .SharedCriterionService)) { Selector selector = new Selector() { fields = new string[] { SharedSet.Fields.SharedSetId, Criterion.Fields.Id, Keyword.Fields.KeywordText, Keyword.Fields.KeywordMatchType, Placement.Fields.PlacementUrl }, predicates = new Predicate[] { Predicate.In(SharedSet.Fields.SharedSetId, sharedSetIds) }, paging = Paging.Default }; List<SharedCriterion> sharedCriteria = new List<SharedCriterion>(); SharedCriterionPage page = new SharedCriterionPage(); try { do { // Get the campaigns. page = sharedCriterionService.get(selector); // Display the results. if (page != null && page.entries != null) { int i = selector.paging.startIndex; foreach (SharedCriterion sharedCriterion in page.entries) { switch (sharedCriterion.criterion.type) { case CriterionType.KEYWORD: Keyword keyword = (Keyword) sharedCriterion.criterion; Console.WriteLine( "{0}) Shared negative keyword with ID {1} and " + "text '{2}' was found.", i + 1, keyword.id, keyword.text); break; case CriterionType.PLACEMENT: Placement placement = (Placement) sharedCriterion.criterion; Console.WriteLine( "{0}) Shared negative placement with ID {1} and " + "URL '{2}' was found.", i + 1, placement.id, placement.url); break; default: Console.WriteLine( "{0}) Shared criteria with ID {1} was found.", i + 1, sharedCriterion.criterion.id); break; } i++; sharedCriteria.Add(sharedCriterion); } } selector.paging.IncreaseOffset(); } while (selector.paging.startIndex < page.totalNumEntries); return sharedCriteria; } catch (Exception e) { throw new Exception("Failed to get shared criteria.", e); } } } /// <summary> /// Removes a list of shared criteria. /// </summary> /// <param name="user">The user that owns the shared criteria.</param> /// <param name="sharedCriteria">The list shared criteria to be removed.</param> private void RemoveSharedCriteria(AdWordsUser user, List<SharedCriterion> sharedCriteria) { if (sharedCriteria.Count == 0) { Console.WriteLine("No shared criteria to remove."); return; } using (SharedCriterionService sharedCriterionService = (SharedCriterionService) user.GetService(AdWordsService.v201809 .SharedCriterionService)) { List<SharedCriterionOperation> operations = new List<SharedCriterionOperation>(); foreach (SharedCriterion sharedCriterion in sharedCriteria) { operations.Add(new SharedCriterionOperation() { @operator = Operator.REMOVE, operand = new SharedCriterion() { sharedSetId = sharedCriterion.sharedSetId, criterion = new Criterion() { id = sharedCriterion.criterion.id } } }); } try { SharedCriterionReturnValue sharedCriterionReturnValue = sharedCriterionService.mutate(operations.ToArray()); foreach (SharedCriterion removedCriterion in sharedCriterionReturnValue.value) { Console.WriteLine( "Shared criterion ID {0} was successfully removed from shared " + "set ID {1}.", removedCriterion.criterion.id, removedCriterion.sharedSetId); } } catch (Exception e) { throw new Exception("Failed to remove shared criteria.", e); } } } } }
Get ad group level bid modifiers
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example illustrates how to retrieve ad group level mobile bid /// modifiers for a campaign. /// </summary> public class GetAdGroupBidModifiers : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { GetAdGroupBidModifiers codeExample = new GetAdGroupBidModifiers(); Console.WriteLine(codeExample.Description); try { long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE"); codeExample.Run(new AdWordsUser(), campaignId); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example illustrates how to retrieve ad group level mobile bid " + "modifiers for a campaign."; } } /// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="campaignId">Id of the campaign.</param> public void Run(AdWordsUser user, long campaignId) { using (AdGroupBidModifierService adGroupBidModifierService = (AdGroupBidModifierService) user.GetService(AdWordsService.v201809 .AdGroupBidModifierService)) { // Get all ad group bid modifiers for the campaign. Selector selector = new Selector() { fields = new string[] { AdGroupBidModifier.Fields.CampaignId, AdGroupBidModifier.Fields.AdGroupId, AdGroupBidModifier.Fields.BidModifier, AdGroupBidModifier.Fields.BidModifierSource, Criterion.Fields.CriteriaType, Criterion.Fields.Id }, predicates = new Predicate[] { Predicate.Equals(AdGroupBidModifier.Fields.CampaignId, campaignId) }, paging = Paging.Default }; AdGroupBidModifierPage page = new AdGroupBidModifierPage(); try { do { // Get the campaigns. page = adGroupBidModifierService.get(selector); // Display the results. if (page != null && page.entries != null) { int i = selector.paging.startIndex; foreach (AdGroupBidModifier adGroupBidModifier in page.entries) { string bidModifier = (adGroupBidModifier.bidModifierSpecified) ? adGroupBidModifier.bidModifier.ToString() : "UNSET"; Console.WriteLine( "{0}) Campaign ID {1}, AdGroup ID {2}, Criterion ID {3} has " + "ad group level modifier: {4} and source = {5}.", i + 1, adGroupBidModifier.campaignId, adGroupBidModifier.adGroupId, adGroupBidModifier.criterion.id, bidModifier, adGroupBidModifier.bidModifierSource); i++; } } selector.paging.IncreaseOffset(); } while (selector.paging.startIndex < page.totalNumEntries); Console.WriteLine("Number of adgroup bid modifiers found: {0}", page.totalNumEntries); } catch (Exception e) { throw new System.ApplicationException( "Failed to retrieve adgroup bid modifiers.", e); } } } } }
Add a portfolio bidding strategy to a campaign
// Copyright 2018 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using Google.Api.Ads.AdWords.Lib; using Google.Api.Ads.AdWords.v201809; using System; namespace Google.Api.Ads.AdWords.Examples.CSharp.v201809 { /// <summary> /// This code example adds a portfolio bidding strategy and uses it to /// construct a campaign. /// </summary> public class UsePortfolioBiddingStrategy : ExampleBase { /// <summary> /// Main method, to run this code example as a standalone application. /// </summary> /// <param name="args">The command line arguments.</param> public static void Main(string[] args) { UsePortfolioBiddingStrategy codeExample = new UsePortfolioBiddingStrategy(); Console.WriteLine(codeExample.Description); try { codeExample.Run(new AdWordsUser()); } catch (Exception e) { Console.WriteLine("An exception occurred while running this code example. {0}", ExampleUtilities.FormatException(e)); } } /// <summary> /// Returns a description about the code example. /// </summary> public override string Description { get { return "This code example adds a portfolio bidding strategy and uses it to " + "construct a campaign."; } } /// <summary> /// Runs the specified code example. /// </summary> /// <param name="user">The AdWords user.</param> public void Run(AdWordsUser user) { string BIDDINGSTRATEGY_NAME = "Maximize Clicks " + ExampleUtilities.GetRandomString(); const long BID_CEILING = 2000000; const long SPEND_TARGET = 20000000; string BUDGET_NAME = "Shared Interplanetary Budget #" + ExampleUtilities.GetRandomString(); const long BUDGET_AMOUNT = 30000000; string CAMPAIGN_NAME = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(); try { SharedBiddingStrategy portfolioBiddingStrategy = CreateBiddingStrategy(user, BIDDINGSTRATEGY_NAME, BID_CEILING, SPEND_TARGET); Console.WriteLine( "Portfolio bidding strategy with name '{0}' and ID {1} of type " + "{2} was created.", portfolioBiddingStrategy.name, portfolioBiddingStrategy.id, portfolioBiddingStrategy.biddingScheme.BiddingSchemeType); Budget sharedBudget = CreateSharedBudget(user, BUDGET_NAME, BUDGET_AMOUNT); Campaign newCampaign = CreateCampaignWithBiddingStrategy(user, CAMPAIGN_NAME, portfolioBiddingStrategy.id, sharedBudget.budgetId); Console.WriteLine( "Campaign with name '{0}', ID {1} and bidding scheme ID {2} was " + "created.", newCampaign.name, newCampaign.id, newCampaign.biddingStrategyConfiguration.biddingStrategyId); } catch (Exception e) { throw new System.ApplicationException( "Failed to create campaign that uses portfolio " + "bidding strategy.", e); } } /// <summary> /// Creates the portfolio bidding strategy. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="name">The bidding strategy name.</param> /// <param name="bidCeiling">The bid ceiling.</param> /// <param name="spendTarget">The spend target.</param> /// <returns>The bidding strategy object.</returns> private SharedBiddingStrategy CreateBiddingStrategy(AdWordsUser user, string name, long bidCeiling, long spendTarget) { using (BiddingStrategyService biddingStrategyService = (BiddingStrategyService) user.GetService(AdWordsService.v201809 .BiddingStrategyService)) { // Create a portfolio bidding strategy. SharedBiddingStrategy portfolioBiddingStrategy = new SharedBiddingStrategy { name = name }; TargetSpendBiddingScheme biddingScheme = new TargetSpendBiddingScheme { // Optionally set additional bidding scheme parameters. bidCeiling = new Money { microAmount = bidCeiling }, spendTarget = new Money { microAmount = spendTarget } }; portfolioBiddingStrategy.biddingScheme = biddingScheme; // Create operation. BiddingStrategyOperation operation = new BiddingStrategyOperation { @operator = Operator.ADD, operand = portfolioBiddingStrategy }; return biddingStrategyService.mutate(new BiddingStrategyOperation[] { operation }).value[0]; } } /// <summary> /// Creates an explicit budget to be used only to create the Campaign. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="name">The budget name.</param> /// <param name="amount">The budget amount.</param> /// <returns>The budget object.</returns> private Budget CreateSharedBudget(AdWordsUser user, string name, long amount) { using (BudgetService budgetService = (BudgetService) user.GetService(AdWordsService.v201809.BudgetService)) { // Create a shared budget Budget budget = new Budget { name = name, amount = new Money { microAmount = amount }, deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD, isExplicitlyShared = true }; // Create operation. BudgetOperation operation = new BudgetOperation { operand = budget, @operator = Operator.ADD }; // Make the mutate request. return budgetService.mutate(new BudgetOperation[] { operation }).value[0]; } } /// <summary> /// Creates the campaign with a portfolio bidding strategy. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="name">The campaign name.</param> /// <param name="biddingStrategyId">The bidding strategy id.</param> /// <param name="sharedBudgetId">The shared budget id.</param> /// <returns>The campaign object.</returns> private Campaign CreateCampaignWithBiddingStrategy(AdWordsUser user, string name, long biddingStrategyId, long sharedBudgetId) { using (CampaignService campaignService = (CampaignService) user.GetService(AdWordsService.v201809.CampaignService)) { // Create campaign. Campaign campaign = new Campaign { name = name, advertisingChannelType = AdvertisingChannelType.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. status = CampaignStatus.PAUSED, // Set the budget. budget = new Budget { budgetId = sharedBudgetId } }; // Set bidding strategy (required). BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration { biddingStrategyId = biddingStrategyId }; campaign.biddingStrategyConfiguration = biddingStrategyConfiguration; // Set network targeting (recommended). NetworkSetting networkSetting = new NetworkSetting { targetGoogleSearch = true, targetSearchNetwork = true, targetContentNetwork = true }; campaign.networkSetting = networkSetting; // Create operation. CampaignOperation operation = new CampaignOperation { operand = campaign, @operator = Operator.ADD }; return campaignService.mutate(new CampaignOperation[] { operation }).value[0]; } } } }