def create_ad_set(self, account_id, name, daily_budget, campaign_id,
optimization_goal, billing_event, bid_amount, targeting,
app_id, app_store_link):
"""
Step 3: create an ad set in campaign we just created. See [Ad Set][1]
for further details on the API used here.
[1]: https://developers.facebook.com/docs/marketing-api/adset
"""
pdata = {
AdSet.Field.name: name,
AdSet.Field.optimization_goal: optimization_goal,
AdSet.Field.billing_event: billing_event,
AdSet.Field.bid_amount: bid_amount,
AdSet.Field.daily_budget: daily_budget,
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.promoted_object: {
'application_id': app_id,
'object_store_url': app_store_link
},
AdSet.Field.targeting: targeting,
}
pdata['status'] = AdSet.Status.paused
adset = AdSet(parent_id=account_id)
adset.remote_create(params=pdata)
return adset[AdSet.Field.id]
def create_adset(campaign=create_adcampaign()):
adset = AdSet(parent_id=test_config.account_id)
adset[AdSet.Field.name] = unique_name('Test Adset')
adset[AdSet.Field.campaign_group_id] = campaign.get_id()
adset[AdSet.Field.targeting] = {
'geo_locations': {
'countries': ['US']
}
}
adset[AdSet.Field.optimization_goal] = AdSet.OptimizationGoal.impressions
adset[AdSet.Field.billing_event] = AdSet.BillingEvent.impressions
adset[AdSet.Field.bid_amount] = 100
adset[AdSet.Field.daily_budget] = 1000
adset.remote_create()
atexit.register(remote_delete, adset)
return adset
def create_adset(campaign_id):
adset = AdSet(parent_id='act_259842962')
adset.update({
AdSet.Field.name: 'My Ad Set',
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.daily_budget: 10000,
AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
AdSet.Field.optimization_goal: AdSet.OptimizationGoal.reach,
AdSet.Field.bid_amount: 2,
AdSet.Field.targeting: {
Targeting.Field.geo_locations: {
'countries': ['IN'],
},
Targeting.Field.age_min: 20,
Targeting.Field.age_max: 24
},
AdSet.Field.status: AdSet.Status.paused,
})
adset.remote_create()
return adset
def create_adset(campaign=None, params={}):
if campaign is None:
campaign = create_campaign()
adset = AdSet(parent_id=test_config.account_id)
adset[AdSet.Field.name] = unique_name('Test Adset')
adset[AdSet.Field.campaign_id] = campaign.get_id()
adset[AdSet.Field.targeting] = {
'geo_locations': {
'countries': ['US'],
},
}
adset[AdSet.Field.optimization_goal] = AdSet.OptimizationGoal.impressions
adset[AdSet.Field.billing_event] = AdSet.BillingEvent.impressions
adset[AdSet.Field.bid_amount] = 100
adset[AdSet.Field.daily_budget] = 1000
adset.update(params)
adset.remote_create()
atexit.register(remote_delete, adset)
return adset
def create_ad_set(self, account_id, name, daily_budget, campaign_id,
optimization_goal, billing_event, bid_amount,
targeting, app_id, app_store_link):
"""
create an ad set in campaign we just created.
"""
pdata = {
AdSet.Field.name: name,
AdSet.Field.optimization_goal: optimization_goal,
AdSet.Field.billing_event: billing_event,
AdSet.Field.bid_amount: bid_amount,
AdSet.Field.daily_budget: daily_budget,
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.promoted_object: {
'application_id': app_id,
'object_store_url': app_store_link
},
AdSet.Field.targeting: targeting,
}
pdata['status'] = AdSet.Status.paused
adset = AdSet(parent_id=account_id)
adset.remote_create(params=pdata)
return adset[AdSet.Field.id]
AdSet.Field.bid_type: AdSet.BidType.cpm, # Bidding for impressions
AdSet.Field.bid_info: {
AdSet.Field.BidInfo.impressions: 500, # $5 per 1000 impression
},
AdSet.Field.daily_budget: 3600, # $36.00
AdSet.Field.start_time: int(time.time()) + 15, # 15 seconds from now
AdSet.Field.campaign_group_id: campaign.get_id_assured(),
AdSet.Field.targeting: {
TargetingSpecsField.geo_locations: {
'countries': [
'US',
],
},
},
})
ad_set.remote_create()
print("**** DONE: Ad Set created:")
pp.pprint(ad_set)
### Upload an image to an account.
img = AdImage(parent_id=my_account.get_id_assured())
img[AdImage.Field.filename] = os.path.join(this_dir, 'test.png')
img.remote_create()
print("**** DONE: Image uploaded:")
pp.pprint(img) # The image hash can be found using img[AdImage.Field.hash]
### Create a creative.
creative = AdCreative(parent_id=my_account.get_id_assured())
creative.update({
AdCreative.Field.title: 'Visit Seattle',
AdCreative.Field.body: 'Beautiful Puget Sound!',
def create_multiple_website_clicks_ads(
account,
name,
country,
titles,
bodies,
urls,
image_paths,
bid_type,
bid_info,
daily_budget=None,
lifetime_budget=None,
start_time=None,
end_time=None,
age_min=None,
age_max=None,
genders=None,
campaign=None,
paused=False,
):
# Check for bad specs
if daily_budget is None:
if lifetime_budget is None:
raise TypeError(
'One of daily_budget or lifetime_budget must be defined.')
elif end_time is None:
raise TypeError(
'If lifetime_budget is defined, end_time must be defined.')
# Create campaign
if not campaign:
campaign = AdCampaign(parent_id=account.get_id_assured())
campaign[AdCampaign.Field.name] = name + ' Campaign'
campaign[AdCampaign.Field.objective] = \
AdCampaign.Objective.website_clicks
campaign[AdCampaign.Field.status] = \
AdCampaign.Status.active if not paused \
else AdCampaign.Status.paused
campaign.remote_create()
# Create ad set
ad_set = AdSet(parent_id=account.get_id_assured())
ad_set[AdSet.Field.campaign_group_id] = campaign.get_id_assured()
ad_set[AdSet.Field.name] = name + ' AdSet'
ad_set[AdSet.Field.bid_type] = bid_type
ad_set[AdSet.Field.bid_info] = bid_info
if daily_budget:
ad_set[AdSet.Field.daily_budget] = daily_budget
else:
ad_set[AdSet.Field.lifetime_budget] = lifetime_budget
if end_time:
ad_set[AdSet.Field.end_time] = end_time
if start_time:
ad_set[AdSet.Field.start_time] = start_time
targeting = {}
targeting[TargetingSpecsField.geo_locations] = {'countries': [country]}
if age_max:
targeting[TargetingSpecsField.age_max] = age_max
if age_min:
targeting[TargetingSpecsField.age_min] = age_min
if genders:
targeting[TargetingSpecsField.genders] = genders
ad_set[AdSet.Field.targeting] = targeting
ad_set.remote_create()
# Upload the images first one by one
image_hashes = []
for image_path in image_paths:
img = AdImage(parent_id=account.get_id_assured())
img[AdImage.Field.filename] = image_path
img.remote_create()
image_hashes.append(img.get_hash())
ADGROUP_BATCH_CREATE_LIMIT = 10
ad_groups_created = []
def callback_failure(response):
raise response.error()
# For each creative permutation
for creative_info_batch in generate_batches(
itertools.product(titles, bodies, urls, image_hashes),
ADGROUP_BATCH_CREATE_LIMIT):
api_batch = account.get_api_assured().new_batch()
for title, body, url, image_hash in creative_info_batch:
# Create the ad
ad = AdGroup(parent_id=account.get_id_assured())
ad[AdGroup.Field.name] = name + ' Ad'
ad[AdGroup.Field.campaign_id] = ad_set.get_id_assured()
ad[AdGroup.Field.creative] = {
AdCreative.Field.title: title,
AdCreative.Field.body: body,
AdCreative.Field.object_url: url,
AdCreative.Field.image_hash: image_hash,
}
ad.remote_create(batch=api_batch, failure=callback_failure)
ad_groups_created.append(ad)
api_batch.execute()
return ad_groups_created
from examples.docs import fixtures
from facebookads import test_config
ad_account_id = test_config.account_id
pixel_id = fixtures.create_ads_pixel().get_id()
campaign_id = fixtures.create_campaign().get_id_assured()
# _DOC open [ADSET_CREATE_CONVERSIONS_PURCHASE]
# _DOC vars [ad_account_id:s, campaign_id, pixel_id]
from facebookads.objects import AdSet, TargetingSpecsField
adset = AdSet(parent_id=ad_account_id)
adset.update(
{
AdSet.Field.name: "Ad Set oCPM",
AdSet.Field.bid_amount: 150,
AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
AdSet.Field.optimization_goal: AdSet.OptimizationGoal.offsite_conversions,
AdSet.Field.promoted_object: {"pixel_id": pixel_id, "custom_event_type": "PURCHASE"},
AdSet.Field.daily_budget: 1000,
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.targeting: {TargetingSpecsField.geo_locations: {"countries": ["US"]}},
}
)
adset.remote_create(params={"status": AdSet.Status.paused})
print(adset)
# _DOC close [ADSET_CREATE_CONVERSIONS_PURCHASE]
adset.remote_delete()
AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
AdSet.Field.bid_amount: 150,
AdSet.Field.daily_budget: 2000,
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.targeting: {
'geo_locations': {
'countries': ['US'],
},
'interests': [
{
'id': 6003139266461,
'name': 'Movies',
},
{
'id': 6003397425735,
'name': 'Tennis',
},
{
'id': 6003659420716,
'name': 'Cooking',
},
],
},
})
adset.remote_create(params={
'status': AdSet.Status.active,
})
# _DOC close [ADSET_CREATE_INTERESTS_TARGETING]
adset.remote_delete()
def create_lead_ad(
self,
account_id,
name,
page_id,
form_id,
optimization_goal,
billing_event,
bid_amount,
daily_budget,
targeting,
image_path,
message,
link,
caption,
description,
cta_type='SIGN_UP',
):
"""
Create Campaign
"""
campaign = Campaign(parent_id=account_id)
campaign[Campaign.Field.name] = name + ' Campaign'
campaign[Campaign.Field.objective] = \
Campaign.Objective.lead_generation
campaign[Campaign.Field.buying_type] = \
Campaign.BuyingType.auction
campaign.remote_create(params={'status': Campaign.Status.paused})
"""
Create AdSet
"""
adset = AdSet(parent_id=account_id)
adset[AdSet.Field.campaign_id] = campaign.get_id_assured()
adset[AdSet.Field.name] = name + ' AdSet'
adset[AdSet.Field.promoted_object] = {
'page_id': page_id,
}
adset[AdSet.Field.optimization_goal] = optimization_goal
adset[AdSet.Field.billing_event] = billing_event
adset[AdSet.Field.bid_amount] = bid_amount
adset[AdSet.Field.daily_budget] = daily_budget
adset[AdSet.Field.targeting] = targeting
adset.remote_create()
"""
Image
"""
image = AdImage(parent_id=account_id)
image[AdImage.Field.filename] = image_path
image.remote_create()
image_hash = image[AdImage.Field.hash]
"""
Create Creative
"""
link_data = LinkData()
link_data[LinkData.Field.message] = message
link_data[LinkData.Field.link] = link
link_data[LinkData.Field.image_hash] = image_hash
link_data[LinkData.Field.caption] = caption
link_data[LinkData.Field.description] = description
link_data[LinkData.Field.call_to_action] = {
'type': cta_type,
'value': {
'lead_gen_form_id': form_id,
},
}
object_story_spec = ObjectStorySpec()
object_story_spec[ObjectStorySpec.Field.page_id] = page_id
object_story_spec[ObjectStorySpec.Field.link_data] = link_data
creative = AdCreative(parent_id=account_id)
creative[AdCreative.Field.name] = name + ' Creative'
creative[AdCreative.Field.object_story_spec] = object_story_spec
creative.remote_create()
"""
Create Ad
"""
ad = Ad(parent_id=account_id)
ad[Ad.Field.name] = name
ad[Ad.Field.adset_id] = adset.get_id_assured()
ad[Ad.Field.creative] = {'creative_id': str(creative.get_id_assured())}
ad.remote_create()
return {
'image_hash': image_hash,
'campaign_id': campaign['id'],
'adset_id': adset['id'],
'creative_id': creative['id'],
'ad_id': ad['id'],
}
adset.update({
AdSet.Field.name: 'Adset Name',
AdSet.Field.optimization_goal: AdSet.OptimizationGoal.reach,
AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
AdSet.Field.daily_budget: 200,
AdSet.Field.promoted_object: {
'page_id': my_page_id,
},
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.targeting: targeting,
AdSet.Field.is_autobid: True,
})
# Remotely create the adset
adset.remote_create(params={
'status': AdSet.Status.active,
})
print("Remotely created the adset")
#### Creating the Ads ########################################################
# The code below was our attempt at creating ads, however, we encountered the
# error with code 100, subcode 144305, title "Error Loading Image," and
# message "The ad image could not be loaded". We checked our code for
# uploading an ad image with two other groups who were able to successfully
# upload an ad and it was the same. So we were unable to find a solution to
# this problem.
'''
# Remote read the adset
a = adset.remote_read(fields=[AdSet.Field.id])
# my_adset_id = a["id"]
def same_os_copy(self, campaign, adset, adgroups):
parent_id = config['act_id'][self.param['account']]
account = AdAccount(parent_id)
custom_audiences = account.get_custom_audiences(
fields=[
CustomAudience.Field.name,
],
params={'limit': 100}
)
copy_custom_audience = []
copy_excluded_custom_audience = []
excluded_ids = self.param.getlist('excluded_custom_audiences')
for i in range(0, len(custom_audiences)):
custom_audience = custom_audiences[i]
if custom_audience['id'] in self.param.getlist('custom_audiences'):
audience = {
'id': custom_audience['id'],
'name': custom_audience['name']
}
copy_custom_audience.append(audience)
if custom_audience['id'] in excluded_ids:
excluded_audience = {
'id': custom_audience['id'],
'name': custom_audience['name']
}
copy_excluded_custom_audience.append(excluded_audience)
copy_targeting = copy.deepcopy(adset['targeting'])
copy_targeting['age_max'] = self.param['age_max']
copy_targeting['age_min'] = self.param['age_min']
copy_targeting['geo_locations']['countries'] = self.param.getlist('countries')
copy_targeting['custom_audiences'] = copy_custom_audience
copy_targeting['excluded_custom_audiences'] = copy_excluded_custom_audience
# Defaults to all. Do not specify 0.
if(self.param['gender']):
copy_targeting['genders'] = [self.param['gender']]
else:
copy_targeting['genders'] = [1, 2]
copy_adset = AdSet(parent_id=parent_id)
copy_adset.update({
AdSet.Field.name: self.param['adset_name'],
AdSet.Field.daily_budget: adset['daily_budget'],
AdSet.Field.promoted_object: adset['promoted_object'],
AdSet.Field.is_autobid: adset['is_autobid'],
AdSet.Field.targeting: copy_targeting,
AdSet.Field.status: self.param['status'],
AdSet.Field.campaign_group_id: self.param['campaign_id'],
AdSet.Field.billing_event: adset['billing_event'],
AdSet.Field.optimization_goal: adset['optimization_goal'],
AdSet.Field.rtb_flag: adset['rtb_flag']
})
if 'bid_amount' in adset:
copy_adset.update({
AdSet.Field.bid_amount: adset['bid_amount']
})
copy_adset.remote_create()
print("*** DONE: Copy AdSet ***")
pp.pprint(copy_adset)
adgroups = adset.get_ad_groups(
fields=[
AdGroup.Field.name,
AdGroup.Field.creative,
AdGroup.Field.tracking_specs,
AdGroup.Field.status
],
params={
AdGroup.Field.status: ['ACTIVE']
}
)
for i in range(0, len(adgroups)):
adgroup = adgroups[i]
copy_adgroup = AdGroup(parent_id=parent_id)
copy_adgroup.update({
AdGroup.Field.name: adgroup['name'],
AdGroup.Field.campaign_id: copy_adset['id'],
AdGroup.Field.status: adgroup['adgroup_status'],
AdGroup.Field.creative: {
AdGroup.Field.Creative.creative_id: adgroup['creative']['id']
},
AdGroup.Field.tracking_specs: adgroup['tracking_specs']
})
copy_adgroup.remote_create()
print("*** DONE: Copy AdGroup ***")
pp.pprint(copy_adgroup)
result = {
'adset': copy_adset,
'campaign': campaign,
'adgroups': adgroups
}
return result
def different_os_copy(self, campaign, adset, adgroups):
parent_id = config['act_id'][self.param['account']]
link_url = config['link_url'][self.param['account']][self.param['os']]
account = AdAccount(parent_id)
custom_audiences = account.get_custom_audiences(
fields=[
CustomAudience.Field.name,
],
params={'limit': 100}
)
copy_custom_audience = []
copy_excluded_audience = []
for i in range(0, len(custom_audiences)):
custom_audience = custom_audiences[i]
if custom_audience['id'] in self.param.getlist('custom_audiences'):
audience = {
'id': custom_audience['id'],
'name': custom_audience['name']
}
copy_custom_audience.append(audience)
if custom_audience['id'] in self.param.getlist('excluded_custom_audiences'):
excluded_audience = {
'id': custom_audience['id'],
'name': custom_audience['name']
}
copy_excluded_audience.append(excluded_audience)
copy_promoted_object = copy.deepcopy(adset['promoted_object'])
copy_promoted_object['object_store_url'] = link_url
copy_targeting = copy.deepcopy(adset['targeting'])
copy_targeting['user_os'] = [config['user_os'][self.param['os']]]
copy_targeting['age_max'] = self.param['age_max']
copy_targeting['age_min'] = self.param['age_min']
copy_targeting['geo_locations']['countries'] = self.param.getlist('countries')
copy_targeting['custom_audiences'] = copy_custom_audience
copy_targeting['excluded_custom_audiences'] = copy_excluded_audience
# Default to all.
if 'user_device' in copy_targeting:
del copy_targeting['user_device']
# Defaults to all. Do not specify 0.
if(self.param['gender']):
copy_targeting['genders'] = [self.param['gender']]
else:
copy_targeting['genders'] = [1, 2]
copy_adset = AdSet(parent_id=parent_id)
copy_adset.update({
AdSet.Field.name: self.param['adset_name'],
AdSet.Field.daily_budget: adset['daily_budget'],
AdSet.Field.promoted_object: copy_promoted_object,
AdSet.Field.is_autobid: adset['is_autobid'],
AdSet.Field.targeting: copy_targeting,
AdSet.Field.status: self.param['status'],
AdSet.Field.campaign_group_id: self.param['campaign_id'],
AdSet.Field.billing_event: adset['billing_event'],
AdSet.Field.optimization_goal: adset['optimization_goal'],
AdSet.Field.rtb_flag: adset['rtb_flag']
})
if 'bid_amount' in adset:
copy_adset.update({
AdSet.Field.bid_amount: adset['bid_amount']
})
copy_adset.remote_create()
print("*** DONE: Copy AdSet ***")
pp.pprint(copy_adset)
creatives = adset.get_ad_creatives(
fields=[
AdCreative.Field.name,
AdCreative.Field.object_story_spec
],
params={
'limit': 50
}
)
for i in range(0, len(adgroups)):
adgroup = adgroups[i]
creative = {}
for j in range(0, len(creatives)):
if (adgroup['creative']['id'] == creatives[j]['id']):
creative = creatives[j]
break
object_story_spec = creative['object_story_spec']
if 'link_data' in object_story_spec:
copy_object_story_spec = self.get_object_story_spec_for_image(
object_story_spec,
link_url
)
elif 'video_data' in object_story_spec:
copy_object_story_spec = self.get_object_story_spec_for_video(
object_story_spec,
link_url
)
else:
break
copy_creative = AdCreative(parent_id=parent_id)
copy_creative[AdCreative.Field.name] = creative['name'],
copy_creative[AdCreative.Field.object_story_spec] = copy_object_story_spec
copy_creative.remote_create()
print("*** DONE: Copy Creative ***")
pp.pprint(copy_creative)
copy_adgroup = AdGroup(parent_id=parent_id)
copy_adgroup.update({
AdGroup.Field.name: adgroup['name'],
AdGroup.Field.campaign_id: copy_adset['id'],
AdGroup.Field.status: adgroup['adgroup_status'],
AdGroup.Field.creative: {
AdGroup.Field.Creative.creative_id: copy_creative['id']
},
AdGroup.Field.tracking_specs: adgroup['tracking_specs']
})
copy_adgroup.remote_create()
print("*** DONE: Copy AdGroup ***")
pp.pprint(copy_adgroup)
result = {
'adset': copy_adset,
'campaign': campaign,
'adgroups': adgroups
}
return result
def create_multiple_website_clicks_ads(
account,
name,
country,
titles,
bodies,
urls,
image_paths,
bid_type,
bid_info,
daily_budget=None,
lifetime_budget=None,
start_time=None,
end_time=None,
age_min=None,
age_max=None,
genders=None,
campaign=None,
paused=False,
):
# Check for bad specs
if daily_budget is None:
if lifetime_budget is None:
raise TypeError(
'One of daily_budget or lifetime_budget must be defined.'
)
elif end_time is None:
raise TypeError(
'If lifetime_budget is defined, end_time must be defined.'
)
# Create campaign
if not campaign:
campaign = AdCampaign(parent_id=account.get_id_assured())
campaign[AdCampaign.Field.name] = name + ' Campaign'
campaign[AdCampaign.Field.objective] = \
AdCampaign.Objective.website_clicks
campaign[AdCampaign.Field.status] = \
AdCampaign.Status.active if not paused \
else AdCampaign.Status.paused
campaign.remote_create()
# Create ad set
ad_set = AdSet(parent_id=account.get_id_assured())
ad_set[AdSet.Field.campaign_group_id] = campaign.get_id_assured()
ad_set[AdSet.Field.name] = name + ' AdSet'
ad_set[AdSet.Field.bid_type] = bid_type
ad_set[AdSet.Field.bid_info] = bid_info
if daily_budget:
ad_set[AdSet.Field.daily_budget] = daily_budget
else:
ad_set[AdSet.Field.lifetime_budget] = lifetime_budget
if end_time:
ad_set[AdSet.Field.end_time] = end_time
if start_time:
ad_set[AdSet.Field.start_time] = start_time
targeting = {}
targeting[TargetingSpecsField.geo_locations] = {
'countries': [country]
}
if age_max:
targeting[TargetingSpecsField.age_max] = age_max
if age_min:
targeting[TargetingSpecsField.age_min] = age_min
if genders:
targeting[TargetingSpecsField.genders] = genders
ad_set[AdSet.Field.targeting] = targeting
ad_set.remote_create()
# Upload the images first one by one
image_hashes = []
for image_path in image_paths:
img = AdImage(parent_id=account.get_id_assured())
img[AdImage.Field.filename] = image_path
img.remote_create()
image_hashes.append(img.get_hash())
ADGROUP_BATCH_CREATE_LIMIT = 10
ad_groups_created = []
def callback_failure(response):
raise response.error()
# For each creative permutation
for creative_info_batch in generate_batches(
itertools.product(titles, bodies, urls, image_hashes),
ADGROUP_BATCH_CREATE_LIMIT
):
api_batch = account.get_api_assured().new_batch()
for title, body, url, image_hash in creative_info_batch:
# Create the ad
ad = AdGroup(parent_id=account.get_id_assured())
ad[AdGroup.Field.name] = name + ' Ad'
ad[AdGroup.Field.campaign_id] = ad_set.get_id_assured()
ad[AdGroup.Field.creative] = {
AdCreative.Field.title: title,
AdCreative.Field.body: body,
AdCreative.Field.object_url: url,
AdCreative.Field.image_hash: image_hash,
}
ad.remote_create(batch=api_batch, failure=callback_failure)
ad_groups_created.append(ad)
api_batch.execute()
return ad_groups_created
def create_multiple_link_clicks_ads(
self,
accountid,
pageid,
name,
titles,
bodies,
urls,
image_paths,
targeting,
optimization_goal,
billing_event,
bid_amount,
daily_budget=None,
lifetime_budget=None,
start_time=None,
end_time=None,
):
"""
There are 7 steps in this sample:
1. Create a campaign
2. Create an ad set
3. Upload images
4. Make combinations of specified creative elements
5. Prepare an API batch
6. For each creative combination, add a call to the batch to create a
new ad
7. Execute API batch
Params:
* `accountid` is your Facebook AdAccount id
* `name` is a string of basename of your ads.
* `page` is the Facebook page used to publish the ads
* `titles` array of strings of what user will see as ad title
* `bodies` array of strings of what user will see as ad body
* `image_paths` array of image file paths
* `targeting` is a JSON string specifying targeting info of your ad
See [Targeting Specs](https://developers.facebook.com/docs/marketing-api/targeting-specs)
for details.
* `optimization_goal` the optimization goal for the adsets
* `billing_event` what you want to pay for
* `bid_amount` how much you want to pay per billing event
* `daily_budget` is integer number in your currency. E.g., if your
currency is USD, dailybudget=1000 says your budget is 1000 USD
* `lifetime_budget` lifetime budget for created ads
* `start_time` when the campaign should start
* `end_time` when the campaign should end
"""
my_account = AdAccount(fbid=accountid)
"""
Take different title body url and image paths, create a batch of
ads based on the permutation of these elements
"""
# Check for bad specs
if daily_budget is None:
if lifetime_budget is None:
raise TypeError(
'One of daily_budget or lifetime_budget must be defined.')
elif end_time is None:
raise TypeError(
'If lifetime_budget is defined, end_time must be defined.')
"""
Step 1: Create new campaign with WEBSITE_CLICKS objective
See
[Campaign Group](https://developers.facebook.com/docs/marketing-api/reference/ad-campaign-group)
for further details on the API used here.
"""
campaign = Campaign(parent_id=accountid)
campaign[Campaign.Field.name] = name + ' Campaign'
campaign[Campaign.Field.objective] = \
Campaign.Objective.link_clicks
campaign.remote_create(params={
'status': Campaign.Status.paused,
})
"""
Step 2: Create AdSet using specified optimization goal, billing event
and bid.
See
[AdSet](https://developers.facebook.com/docs/marketing-api/reference/ad-campaign)
for further details on the API used here.
"""
# Create ad set
ad_set = AdSet(parent_id=accountid)
ad_set[AdSet.Field.campaign_id] = campaign.get_id_assured()
ad_set[AdSet.Field.name] = name + ' AdSet'
ad_set[AdSet.Field.optimization_goal] = optimization_goal
ad_set[AdSet.Field.billing_event] = billing_event
ad_set[AdSet.Field.bid_amount] = bid_amount
if daily_budget:
ad_set[AdSet.Field.daily_budget] = daily_budget
else:
ad_set[AdSet.Field.lifetime_budget] = lifetime_budget
if end_time:
ad_set[AdSet.Field.end_time] = end_time
if start_time:
ad_set[AdSet.Field.start_time] = start_time
ad_set[AdSet.Field.targeting] = targeting
ad_set.remote_create()
"""
Step 3: Upload images and get image hashes for use in ad creative.
See
[Ad Image](https://developers.facebook.com/docs/marketing-api/reference/ad-image#Creating)
for further details on the API used here.
"""
# Upload the images first one by one
image_hashes = []
for image_path in image_paths:
img = AdImage(parent_id=accountid)
img[AdImage.Field.filename] = image_path
img.remote_create()
image_hashes.append(img.get_hash())
ADGROUP_BATCH_CREATE_LIMIT = 10
ads_created = []
def callback_failure(response):
raise response.error()
"""
Step 4: Using itertools.product get combinations of creative
elements.
"""
for creative_info_batch in generate_batches(
itertools.product(titles, bodies, urls, image_hashes),
ADGROUP_BATCH_CREATE_LIMIT):
"""
Step 5: Create an API batch so we can create all
ad creatives with one HTTP request.
See
[Batch Requests](https://developers.facebook.com/docs/graph-api/making-multiple-requests#simple)
for further details on batching API calls.
"""
api_batch = my_account.get_api_assured().new_batch()
for title, body, url, image_hash in creative_info_batch:
# Create the ad
"""
Step 6: For each combination of creative elements,
add to the batch an API call to create a new Ad
and specify the creative inline.
See
[AdGroup](https://developers.facebook.com/docs/marketing-api/adgroup/)
for further details on creating Ads.
"""
ad = Ad(parent_id=accountid)
ad[Ad.Field.name] = name + ' Ad'
ad[Ad.Field.adset_id] = ad_set.get_id_assured()
ad[Ad.Field.creative] = {
AdCreative.Field.object_story_spec: {
"page_id": pageid,
"link_data": {
"message": body,
"link": url,
"caption": title,
"image_hash": image_hash
}
},
}
ad.remote_create(batch=api_batch, failure=callback_failure)
ads_created.append(ad)
"""
Step 7: Execute the batched API calls
See
[Batch Requests](https://developers.facebook.com/docs/graph-api/making-multiple-requests#simple)
for further details on batching API calls.
"""
api_batch.execute()
return [campaign, ad_set, ads_created]
# _DOC open [ADSET_CREATE_DYNAMIC_PROSPECTIING]
# _DOC vars [ad_account_id:s, product_set_id, campaign_id]
from facebookads.objects import AdSet, TargetingSpecsField
adset = AdSet(parent_id=ad_account_id)
adset[AdSet.Field.name] = 'Case 1 Adset'
adset[AdSet.Field.bid_amount] = 3000
adset[AdSet.Field.billing_event] = AdSet.BillingEvent.link_clicks
adset[AdSet.Field.optimization_goal] = AdSet.OptimizationGoal.link_clicks
adset[AdSet.Field.daily_budget] = 15000
adset[AdSet.Field.campaign_id] = campaign_id
adset[AdSet.Field.targeting] = {
TargetingSpecsField.geo_locations: {
TargetingSpecsField.countries: ['US'],
},
TargetingSpecsField.interests: [{
'id': 6003397425735,
'name': 'Tennis',
}],
}
adset[AdSet.Field.promoted_object] = {'product_set_id': product_set_id}
behavior = 'FALL_BACK_TO_FB_RECOMMENDATIONS'
adset[AdSet.Field.product_ad_behavior] = behavior
adset.remote_create(params={
'status': AdSet.Status.paused,
})
# _DOC close [ADSET_CREATE_DYNAMIC_PROSPECTIING]
adset.remote_delete()
AdSet.Field.bid_type: AdSet.BidType.cpm, # Bidding for impressions
AdSet.Field.bid_info: {
AdSet.Field.BidInfo.impressions: 500, # $5 per 1000 impression
},
AdSet.Field.daily_budget: 3600, # $36.00
AdSet.Field.start_time: int(time.time()) + 15, # 15 seconds from now
AdSet.Field.campaign_group_id: campaign.get_id_assured(),
AdSet.Field.targeting: {
TargetingSpecsField.geo_locations: {
'countries': [
'US',
],
},
},
})
ad_set.remote_create()
print("**** DONE: Ad Set created:")
pp.pprint(ad_set)
### Upload an image to an account.
img = AdImage(parent_id=my_account.get_id_assured())
img[AdImage.Field.filename] = os.path.join(
os.path.dirname(__file__),
os.pardir,
'facebookads/test/misc/image.png'
)
img.remote_create()
print("**** DONE: Image uploaded:")
pp.pprint(img) # The image hash can be found using img[AdImage.Field.hash]
### Create a creative.
def create_carousel_ad(
self,
accountid,
page_id,
site_link,
caption,
message,
optimization_goal,
billing_event,
bid_amount,
name,
targeting,
products,
call_to_action_type=None,
):
"""
There are 5 steps in this sample:
1. Create a campaign
2. Create an ad set
3. For each product:
a. Upload the product's image and get an image hash
b. Create a story attachment using the product's creative elements
4. Prepare the ad creative
5. Create the ad using the ad creative
"""
daily_budget = 10000
"""
Step 1: Create new campaign with WEBSITE_CLICKS objective
See
[Campaign Group](https://developers.facebook.com/docs/marketing-api/reference/ad-campaign-group)
for further details on the API used here.
"""
campaign = Campaign(parent_id=accountid)
campaign[Campaign.Field.name] = name + ' Campaign'
campaign[Campaign.Field.objective] = \
Campaign.Objective.link_clicks
campaign.remote_create(params={'status': Campaign.Status.paused})
"""
Step 2: Create AdSet using specified optimization goal, billing event
and bid.
See
[AdSet](https://developers.facebook.com/docs/marketing-api/reference/ad-campaign)
for further details on the API used here.
"""
ad_set = AdSet(parent_id=accountid)
ad_set[AdSet.Field.campaign_id] = campaign.get_id_assured()
ad_set[AdSet.Field.name] = name + ' AdSet'
ad_set[AdSet.Field.optimization_goal] = optimization_goal
ad_set[AdSet.Field.billing_event] = billing_event
ad_set[AdSet.Field.bid_amount] = bid_amount
ad_set[AdSet.Field.daily_budget] = daily_budget
ad_set[AdSet.Field.targeting] = targeting
ad_set.remote_create()
story_attachments = []
"""
Step 3: Upload images and get image hashes for use in ad creative.
See
[Ad Image](https://developers.facebook.com/docs/marketing-api/reference/ad-image#Creating)
for further details on the API used here.
Then create a new attachment with the product's creative
"""
call_to_action = {
'type': call_to_action_type,
'value': {
'link': site_link,
'link_caption': call_to_action_type,
}
} if call_to_action_type else None
for product in products:
img = AdImage(parent_id=accountid)
img[AdImage.Field.filename] = product['image_path']
img.remote_create()
image_hash = img.get_hash()
attachment = AttachmentData()
attachment[AttachmentData.Field.link] = product['link']
attachment[AttachmentData.Field.name] = product['name']
attachment[
AttachmentData.Field.description] = product['description']
attachment[AttachmentData.Field.image_hash] = image_hash
if call_to_action:
attachment[
AttachmentData.Field.call_to_action] = call_to_action
story_attachments.append(attachment)
"""
Step 4: Prepare the ad creative including link information
Note that here we specify multi_share_optimized = True
this means you can add up to 10 products and Facebook will
automatically select the best performing 5 to show in the ad. Facebook
will also select the best ordering of those products.
"""
link = LinkData()
link[link.Field.link] = site_link
link[link.Field.caption] = caption
link[link.Field.child_attachments] = story_attachments
link[link.Field.multi_share_optimized] = True
link[link.Field.call_to_action] = call_to_action
story = ObjectStorySpec()
story[story.Field.page_id] = page_id
story[story.Field.link_data] = link
creative = AdCreative()
creative[AdCreative.Field.name] = name + ' Creative'
creative[AdCreative.Field.object_story_spec] = story
"""
Step 5: Create the ad using the above creative
"""
ad = Ad(parent_id=accountid)
ad[Ad.Field.name] = name + ' Ad'
ad[Ad.Field.adset_id] = ad_set.get_id_assured()
ad[Ad.Field.creative] = creative
ad.remote_create(params={'status': Ad.Status.paused})
return (campaign, ad_set, ad)
},
},
],
},
],
TargetingSpecsField.excluded_product_audience_specs: [
{
'product_set_id': product_set_id,
'inclusions': [
{
'retention_seconds': 259200,
'rule': {
'event': {
'eq': 'ViewContent',
},
},
},
],
},
],
}
adset[AdSet.Field.promoted_object] = {
'product_set_id': product_set_id,
}
adset[AdSet.Field.product_ad_behavior] = 'FALL_BACK_TO_FB_RECOMMENDATIONS'
adset.remote_create()
# _DOC close [ADSET_CREATE_PRODUCT_CATALOG_SALES_VIEWED_DAYS_RETENTION]
adset.remote_delete()
def create_lookalike_ads(
self,
account_id,
name,
tiered_lookalikes,
optimization_goal,
billing_event,
tiered_bid_amounts,
title,
body,
url,
image_path,
daily_budget=None,
lifetime_budget=None,
start_time=None,
end_time=None,
campaign=None,
):
"""
Take the tiered lookalike audiences and create the ads
"""
results = {
'adsets': [],
'ads': [],
}
tiers = len(tiered_lookalikes)
if tiers != len(tiered_bid_amounts):
raise TypeError('Audience and bid amount number mismatch.')
# Create campaign
if not campaign:
campaign = Campaign(parent_id=account_id)
campaign[Campaign.Field.name] = '{} Campaign'.format(name)
campaign[Campaign.Field.objective] = \
Campaign.Objective.link_clicks
campaign.remote_create(params={
'status': Campaign.Status.paused,
})
# Upload image
img = AdImage(parent_id=account_id)
img[AdImage.Field.filename] = image_path
img.remote_create()
image_hash = img.get_hash()
# Inline creative for ads
inline_creative = {
AdCreative.Field.title: title,
AdCreative.Field.body: body,
AdCreative.Field.object_url: url,
AdCreative.Field.image_hash: image_hash,
}
for tier in range(1, tiers + 1):
# Create ad set
ad_set = AdSet(parent_id=account_id)
ad_set[AdSet.Field.campaign_id] = campaign.get_id_assured()
ad_set[AdSet.Field.name] = '{0} AdSet tier {1}'.format(name, tier)
ad_set[AdSet.Field.optimization_goal] = optimization_goal
ad_set[AdSet.Field.billing_event] = billing_event
ad_set[AdSet.Field.bid_amount] = tiered_bid_amounts[tier - 1]
if daily_budget:
ad_set[AdSet.Field.daily_budget] = daily_budget
else:
ad_set[AdSet.Field.lifetime_budget] = lifetime_budget
if end_time:
ad_set[AdSet.Field.end_time] = end_time
if start_time:
ad_set[AdSet.Field.start_time] = start_time
audience = tiered_lookalikes[tier - 1]
targeting = {
TargetingSpecsField.custom_audiences: [{
'id': audience[CustomAudience.Field.id],
'name': audience[CustomAudience.Field.name],
}]
}
ad_set[AdSet.Field.targeting] = targeting
ad_set.remote_create(params={
'status': AdSet.Status.paused,
})
# Create ad
ad = Ad(parent_id=account_id)
ad[Ad.Field.name] = '{0} Ad tier {1}'.format(name, tier)
ad[Ad.Field.adset_id] = ad_set['id']
ad[Ad.Field.creative] = inline_creative
ad.remote_create(params={
'status': Ad.Status.paused,
})
results['adsets'].append(ad_set)
results['ads'].append(ad)
return results
