def list_campaigns(): FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) my_account = AdAccount(f'act_{ad_account}') fields = [ 'account_id', 'budget_rebalance_flag', 'budget_remaining', 'buying_type', 'can_create_brand_lift_study', 'can_use_spend_cap', 'configured_status', 'created_time', 'effective_status', 'id', 'name', 'objective', 'recommendations', 'source_campaign', 'source_campaign_id', 'spend_cap', 'start_time', 'status', 'updated_time', ] return my_account.get_campaigns(fields=fields)
def view_campaign(request): FacebookAdsApi.init(access_token=access_token, app_id=app_id, app_secret=app_secret) my_account = AdAccount('act_' + user_id) campaigns = my_account.get_campaigns() camp_id = [] for i in range(len(campaigns)): camp_id.append(campaigns[i]["id"]) campaign_data = [] for id in camp_id: campaign = Campaign(fbid=id) fields = [ Campaign.Field.id, Campaign.Field.name, Campaign.Field.status, ] campaign.remote_read(fields=fields) result = {} result["id"] = campaign[Campaign.Field.id] result["name"] = campaign[Campaign.Field.name] result["status"] = campaign[Campaign.Field.status] result["data_1"] = "ACTIVE" result["data_2"] = "PAUSED" campaign_data.append(result) context = {'campaigns': campaign_data} return render(request, 'fbapp/view_campaign.html', context)
def get_campaign_data(ad_account: adaccount.AdAccount) -> {}: """Retrieves the campaign data of the ad account as a dictionary Args: ad_account: An ad account for which to retrieve the campaign data Returns: A dictionary with {campaign_id: {'name': 1, 'attributes': {}}} format """ logging.info('get campaign data for account {}'.format( ad_account['account_id'])) campaigns = ad_account.get_campaigns(fields=['id', 'name', 'adlabels'], params={ 'limit': 1000, 'status': ['ACTIVE', 'PAUSED', 'ARCHIVED'] }) result = {} for campaign in campaigns: result[campaign['id']] = { 'name': campaign['name'], 'attributes': parse_labels(campaign.get('adlabels', [])) } return result
def get_campaign(account_ids): my_account = AdAccount(account_ids) campaigns = my_account.get_campaigns() params = {'fields': [Campaign.Field.id, Campaign.Field.name]} for campaign in campaigns: print(campaign) campaigns = campaign.api_get(fields=params.get('fields'), params=params) campaign_name = campaigns.get('name') campaign_id = campaigns.get('id') return {'campaign_ids': campaign_id, 'campaign_name': campaign_name}
def FB_data_request(my_app_id, my_app_secret, my_access_token,Accounts,start_date,end_date): FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) fields = ['account_id','account_name','campaign_id','campaign_name','clicks','date_start','frequency','impressions','reach','spend'] params = {'time_range':{'since': start_date,'until': end_date},'time_increment':'1'} FB_df=pd.DataFrame() account_id=[] account_name=[] campaign_id=[] campaign_name=[] clicks=[] date_start=[] frequency=[] impressions=[] reach=[] spend=[] for account in Accounts: my_account = AdAccount('act_'+account) campaigns = my_account.get_campaigns()._queue print(len(campaigns)) for campaign in campaigns: print(campaign.get_id()) #print(campaign) campinsights=campaign.get_insights(fields=fields,params=params) #print(campaign.get('full_view_reach')) print(len(campinsights)) for inscampaign in campinsights: account_id.append(inscampaign['account_id']) account_name.append(inscampaign['account_name']) campaign_id.append(inscampaign['campaign_id']) campaign_name.append(inscampaign['campaign_name']) clicks.append(inscampaign['clicks']) date_start.append(inscampaign['date_start']) frequency.append(inscampaign['frequency']) impressions.append(inscampaign['impressions']) reach.append(inscampaign['reach']) spend.append(inscampaign['spend']) FB_df['Account Id']= account_id FB_df['Account Name']= account_name FB_df['Campaign Id']= campaign_id FB_df['Campaign Name']= campaign_name FB_df['Clicks']= clicks FB_df['Date']= date_start FB_df['Frequency']= frequency FB_df['Impressions']= impressions FB_df['Reach']= reach FB_df['Spend']= spend #FB_df.to_csv('example.csv') print(FB_df.head()) return(FB_df)
def getCampaign(): FacebookAdsApi.init(app_id=dict1['my_app_id'], app_secret=dict1['my_app_secret'], account_id=dict1['account_id'], access_token=dict1['my_access_token']) fields = ['id', 'name', 'objective'] account = AdAccount(dict1['account_id']) campaigns = account.get_campaigns(fields=fields) for i in campaigns: if i['id'] == '120330000453089803': print(i)
def run_query_on_fb_account_obj_conf(self, params, ad_object_id): if ad_object_id.startswith("act_"): raise ClickException( "Wrong format. Account ID should only contains digits") account = AdAccount("act_" + ad_object_id) campaigns = account.get_campaigns() for el in chain(*[ self.run_query_on_fb_campaign_obj_conf(params, campaign.get("id")) for campaign in campaigns ]): yield el
def get_request(account_id, table, params, fields): """account_id: unique id for ad account in format act_<ID> table: The table object found in the models module params: dictionary of parameters for request fields: list of fields for request --> returns requested data from Facebook Marketing API """ my_account = AdAccount(account_id) if table == 'accounts': cursor = my_account.api_get(params=params, fields=fields) return dict(cursor) if table == 'campaigns': cursor = my_account.get_campaigns(params=params, fields=fields) request = [campaign for campaign in cursor] return request if table == 'adsets': request = my_account.get_ad_sets(params=params, fields=fields) return request if table == 'ads_insights': cursor = my_account.get_insights_async(params=params, fields=fields) cursor.api_get() while cursor[AdReportRun.Field.async_status] != "Job Completed": time.sleep(1) cursor.api_get() time.sleep(1) request = cursor.get_result(params={"limit": 1000}) return request if table == 'ads_insights_age_and_gender': cursor = my_account.get_insights_async(params=params, fields=fields) cursor.api_get() while cursor[AdReportRun.Field.async_status] != "Job Completed": time.sleep(1) cursor.api_get() time.sleep(1) request = cursor.get_result(params={"limit": 1000}) return request if table == 'ads_insights_region': cursor = my_account.get_insights_async(params=params, fields=fields) cursor.api_get() while cursor[AdReportRun.Field.async_status] != "Job Completed": time.sleep(1) cursor.api_get() time.sleep(1) request = cursor.get_result(params={"limit": 1000}) return request
class FbApi(object): def __init__(self, config_file=None): self.config_file = config_file self.df = pd.DataFrame() self.config = None self.account = None self.campaign = None self.app_id = None self.app_secret = None self.access_token = None self.act_id = None self.config_list = [] self.date_lists = None self.field_lists = None self.adset_dict = None self.cam_dict = None self.ad_dict = None self.pixel = None if self.config_file: self.input_config(self.config_file) def input_config(self, config_file): logging.info('Loading Facebook config file: ' + str(config_file)) self.config_file = os.path.join(config_path, config_file) self.load_config() self.check_config() FacebookAdsApi.init(self.app_id, self.app_secret, self.access_token) self.account = AdAccount(self.config['act_id']) def load_config(self): try: with open(self.config_file, 'r') as f: self.config = json.load(f) except IOError: logging.error(self.config_file + ' not found. Aborting.') sys.exit(0) self.app_id = self.config['app_id'] self.app_secret = self.config['app_secret'] self.access_token = self.config['access_token'] self.act_id = self.config['act_id'] self.config_list = [ self.app_id, self.app_secret, self.access_token, self.act_id ] def check_config(self): for item in self.config_list: if item == '': logging.warning(item + 'not in FB config file. Aborting.') sys.exit(0) def set_id_name_dict(self, fb_object): if fb_object == Campaign: fields = ['id', 'name'] self.cam_dict = list(self.account.get_campaigns(fields=fields)) elif fb_object == AdSet: fields = ['id', 'name', 'campaign_id'] self.adset_dict = list(self.account.get_ad_sets(fields=fields)) elif fb_object == Ad: fields = ['id', 'name', 'campaign_id', 'adset_id'] self.ad_dict = list(self.account.get_ads(fields=fields)) def campaign_to_id(self, campaigns): if not self.cam_dict: self.set_id_name_dict(Campaign) cids = [x['id'] for x in self.cam_dict if x['name'] in campaigns] return cids def adset_to_id(self, adsets, cids): as_and_cam = list(itertools.product(adsets, cids)) if not self.adset_dict: self.set_id_name_dict(AdSet) asids = [ tuple([x['id'], x['campaign_id']]) for x in self.adset_dict if tuple([x['name'], x['campaign_id']]) in as_and_cam ] return asids def create_campaign(self, campaign_name, objective, status, spend_cap): if not self.cam_dict: self.set_id_name_dict(Campaign) if campaign_name in ([x['name'] for x in self.cam_dict]): logging.warning(campaign_name + ' already in account. This ' + 'campaign was not uploaded.') return None self.campaign = Campaign(parent_id=self.account.get_id_assured()) self.campaign.update({ Campaign.Field.name: campaign_name, Campaign.Field.objective: objective, Campaign.Field.effective_status: status, Campaign.Field.spend_cap: int(spend_cap), Campaign.Field.special_ad_categories: 'NONE' }) self.campaign.remote_create() @staticmethod def geo_target_search(geos): all_geos = [] for geo in geos: params = { 'q': geo, 'type': 'adgeolocation', 'location_types': [Targeting.Field.country], } resp = TargetingSearch.search(params=params) all_geos.extend(resp) return all_geos @staticmethod def target_search(targets_to_search): all_targets = [] for target in targets_to_search[1]: params = { 'q': target, 'type': 'adinterest', } resp = TargetingSearch.search(params=params) if not resp: logging.warning(target + ' not found in targeting search. ' + 'It was not added to the adset.') continue if targets_to_search[0] == 'interest': resp = [resp[0]] new_tar = [dict((k, x[k]) for k in ('id', 'name')) for x in resp] all_targets.extend(new_tar) return all_targets @staticmethod def get_matching_saved_audiences(audiences): aud_list = [] for audience in audiences: audience = CustomAudience(audience) val_aud = audience.remote_read(fields=['targeting']) aud_list.append(val_aud) aud_list = aud_list[0]['targeting'] return aud_list def get_matching_custom_audiences(self, audiences): act_auds = self.account.get_custom_audiences( fields=[CustomAudience.Field.name, CustomAudience.Field.id]) audiences = [{ 'id': x['id'], 'name': x['name'] } for x in act_auds if x['id'] in audiences] return audiences def set_target(self, geos, targets, age_min, age_max, gender, device, publisher_platform, facebook_positions): targeting = {} if geos and geos != ['']: targeting[Targeting.Field.geo_locations] = { Targeting.Field.countries: geos } if age_min: targeting[Targeting.Field.age_min] = age_min if age_max: targeting[Targeting.Field.age_max] = age_max if gender: targeting[Targeting.Field.genders] = gender if device and device != ['']: targeting[Targeting.Field.device_platforms] = device if publisher_platform and publisher_platform != ['']: targeting[Targeting.Field.publisher_platforms] = publisher_platform if facebook_positions and facebook_positions != ['']: targeting[Targeting.Field.facebook_positions] = facebook_positions for target in targets: if target[0] == 'interest' or target[0] == 'interest-broad': int_targets = self.target_search(target) targeting[Targeting.Field.interests] = int_targets if target[0] == 'savedaudience': aud_target = self.get_matching_saved_audiences(target[1]) targeting.update(aud_target) if target[0] == 'customaudience': aud_target = self.get_matching_custom_audiences(target[1]) targeting[Targeting.Field.custom_audiences] = aud_target return targeting def create_adset(self, adset_name, cids, opt_goal, bud_type, bud_val, bill_evt, bid_amt, status, start_time, end_time, prom_obj, country, target, age_min, age_max, genders, device, pubs, pos): if not self.adset_dict: self.set_id_name_dict(AdSet) for cid in cids: if adset_name in ([ x['name'] for x in self.adset_dict if x['campaign_id'] == cid ]): logging.warning(adset_name + ' already in campaign. This ' + 'ad set was not uploaded.') continue targeting = self.set_target(country, target, age_min, age_max, genders, device, pubs, pos) params = { AdSet.Field.name: adset_name, AdSet.Field.campaign_id: cid, AdSet.Field.billing_event: bill_evt, AdSet.Field.status: status, AdSet.Field.targeting: targeting, AdSet.Field.start_time: start_time, AdSet.Field.end_time: end_time, } if bid_amt == '': params['bid_strategy'] = 'LOWEST_COST_WITHOUT_CAP' else: params[AdSet.Field.bid_amount] = int(bid_amt) if opt_goal in [ 'CONTENT_VIEW', 'SEARCH', 'ADD_TO_CART', 'ADD_TO_WISHLIST', 'INITIATED_CHECKOUT', 'ADD_PAYMENT_INFO', 'PURCHASE', 'LEAD', 'COMPLETE_REGISTRATION' ]: if not self.pixel: pixel = self.account.get_ads_pixels() self.pixel = pixel[0]['id'] params[AdSet.Field.promoted_object] = { 'pixel_id': self.pixel, 'custom_event_type': opt_goal, 'page_id': prom_obj } elif 'APP_INSTALLS' in opt_goal: opt_goal = opt_goal.split('|') params[AdSet.Field.promoted_object] = { 'application_id': opt_goal[1], 'object_store_url': opt_goal[2], } else: params[AdSet.Field.optimization_goal] = opt_goal params[AdSet.Field.promoted_object] = {'page_id': prom_obj} if bud_type == 'daily': params[AdSet.Field.daily_budget] = int(bud_val) elif bud_type == 'lifetime': params[AdSet.Field.lifetime_budget] = int(bud_val) self.account.create_ad_set(params=params) def upload_creative(self, creative_class, image_path): cre = creative_class(parent_id=self.account.get_id_assured()) if creative_class == AdImage: cre[AdImage.Field.filename] = image_path cre.remote_create() creative_hash = cre.get_hash() elif creative_class == AdVideo: cre[AdVideo.Field.filepath] = image_path cre.remote_create() creative_hash = cre.get_id() else: creative_hash = None return creative_hash def get_all_thumbnails(self, vid): video = AdVideo(vid) thumbnails = video.get_thumbnails() if not thumbnails: logging.warning('Could not retrieve thumbnail for vid: ' + str(vid) + '. Retrying in 120s.') time.sleep(120) thumbnails = self.get_all_thumbnails(vid) return thumbnails def get_video_thumbnail(self, vid): thumbnails = self.get_all_thumbnails(vid) thumbnail = [x for x in thumbnails if x['is_preferred'] is True] if not thumbnail: thumbnail = thumbnails[1] else: thumbnail = thumbnail[0] thumb_url = thumbnail['uri'] return thumb_url @staticmethod def request_error(e): if e._api_error_code == 2: logging.warning( 'Retrying as the call resulted in the following: ' + str(e)) else: logging.error('Retrying in 120 seconds as the Facebook API call' 'resulted in the following error: ' + str(e)) time.sleep(120) def create_ad(self, ad_name, asids, title, body, desc, cta, durl, url, prom_obj, ig_id, view_tag, ad_status, creative_hash=None, vid_id=None): if not self.ad_dict: self.set_id_name_dict(Ad) for asid in asids: if ad_name in [ x['name'] for x in self.ad_dict if x['campaign_id'] == asid[1] and x['adset_id'] == asid[0] ]: logging.warning(ad_name + ' already in campaign/adset. ' + 'This ad was not uploaded.') continue if vid_id: params = self.get_video_ad_params(ad_name, asid, title, body, desc, cta, url, prom_obj, ig_id, creative_hash, vid_id, view_tag, ad_status) elif isinstance(creative_hash, list): params = self.get_carousel_ad_params(ad_name, asid, title, body, desc, cta, durl, url, prom_obj, ig_id, creative_hash, view_tag, ad_status) else: params = self.get_link_ad_params(ad_name, asid, title, body, desc, cta, durl, url, prom_obj, ig_id, creative_hash, view_tag, ad_status) for attempt_number in range(100): try: self.account.create_ad(params=params) break except FacebookRequestError as e: self.request_error(e) def get_video_ad_params(self, ad_name, asid, title, body, desc, cta, url, prom_obj, ig_id, creative_hash, vid_id, view_tag, ad_status): data = self.get_video_ad_data(vid_id, body, title, desc, cta, url, creative_hash) story = { AdCreativeObjectStorySpec.Field.page_id: str(prom_obj), AdCreativeObjectStorySpec.Field.video_data: data } if ig_id and str(ig_id) != 'nan': story[AdCreativeObjectStorySpec.Field.instagram_actor_id] = ig_id creative = {AdCreative.Field.object_story_spec: story} params = { Ad.Field.name: ad_name, Ad.Field.status: ad_status, Ad.Field.adset_id: asid[0], Ad.Field.creative: creative } if view_tag and str(view_tag) != 'nan': params['view_tags'] = [view_tag] return params def get_link_ad_params(self, ad_name, asid, title, body, desc, cta, durl, url, prom_obj, ig_id, creative_hash, view_tag, ad_status): data = self.get_link_ad_data(body, creative_hash, durl, desc, url, title, cta) story = { AdCreativeObjectStorySpec.Field.page_id: str(prom_obj), AdCreativeObjectStorySpec.Field.link_data: data } if ig_id and str(ig_id) != 'nan': story[AdCreativeObjectStorySpec.Field.instagram_actor_id] = ig_id creative = {AdCreative.Field.object_story_spec: story} params = { Ad.Field.name: ad_name, Ad.Field.status: ad_status, Ad.Field.adset_id: asid[0], Ad.Field.creative: creative } if view_tag and str(view_tag) != 'nan': params['view_tags'] = [view_tag] return params @staticmethod def get_video_ad_data(vid_id, body, title, desc, cta, url, creative_hash): data = { AdCreativeVideoData.Field.video_id: vid_id, AdCreativeVideoData.Field.message: body, AdCreativeVideoData.Field.title: title, AdCreativeVideoData.Field.link_description: desc, AdCreativeVideoData.Field.call_to_action: { 'type': cta, 'value': { 'link': url, }, }, } if creative_hash[:4] == 'http': data[AdCreativeVideoData.Field.image_url] = creative_hash else: data[AdCreativeVideoData.Field.image_hash] = creative_hash return data @staticmethod def get_link_ad_data(body, creative_hash, durl, desc, url, title, cta): data = { AdCreativeLinkData.Field.message: body, AdCreativeLinkData.Field.image_hash: creative_hash, AdCreativeLinkData.Field.caption: durl, AdCreativeLinkData.Field.description: desc, AdCreativeLinkData.Field.link: url, AdCreativeLinkData.Field.name: title, AdCreativeLinkData.Field.call_to_action: { 'type': cta, 'value': { 'link': url, }, }, } return data @staticmethod def get_carousel_ad_data(creative_hash, desc, url, title, cta, vid_id=None): data = { AdCreativeLinkData.Field.description: desc, AdCreativeLinkData.Field.link: url, AdCreativeLinkData.Field.name: title, AdCreativeLinkData.Field.call_to_action: { 'type': cta, 'value': { 'link': url, }, }, } if creative_hash[:4] == 'http': data['picture'] = creative_hash else: data[AdCreativeVideoData.Field.image_hash] = creative_hash if vid_id: data[AdCreativeVideoData.Field.video_id] = vid_id return data @staticmethod def get_individual_carousel_param(param_list, idx): if idx < len(param_list): param = param_list[idx] else: logging.warning('{} does not have index {}. Using last available.' ''.format(param_list, idx)) param = param_list[-1] return param def get_carousel_ad_params(self, ad_name, asid, title, body, desc, cta, durl, url, prom_obj, ig_id, creative_hash, view_tag, ad_status): data = [] for idx, creative in enumerate(creative_hash): current_description = self.get_individual_carousel_param(desc, idx) current_url = self.get_individual_carousel_param(url, idx) current_title = self.get_individual_carousel_param(title, idx) if len(creative) == 1: data_ind = self.get_carousel_ad_data(creative_hash=creative[0], desc=current_description, url=current_url, title=current_title, cta=cta) else: data_ind = self.get_carousel_ad_data(creative_hash=creative[1], desc=current_description, url=current_url, title=current_title, cta=cta, vid_id=creative[0]) data.append(data_ind) link = { AdCreativeLinkData.Field.message: body, AdCreativeLinkData.Field.link: url[0], AdCreativeLinkData.Field.caption: durl, AdCreativeLinkData.Field.child_attachments: data, AdCreativeLinkData.Field.call_to_action: { 'type': cta, 'value': { 'link': url[0], }, }, } story = { AdCreativeObjectStorySpec.Field.page_id: str(prom_obj), AdCreativeObjectStorySpec.Field.link_data: link } if ig_id and str(ig_id) != 'nan': story[AdCreativeObjectStorySpec.Field.instagram_actor_id] = ig_id creative = {AdCreative.Field.object_story_spec: story} params = { Ad.Field.name: ad_name, Ad.Field.status: ad_status, Ad.Field.adset_id: asid[0], Ad.Field.creative: creative } if view_tag and str(view_tag) != 'nan': params['view_tags'] = [view_tag] return params
def device(): today = datetime.date.today() fields1 = [ 'account_name', 'campaign_name', 'campaign_id', 'reach', 'cost_per_action_type:post_reaction', 'action:post_reaction', 'unique_actions:post_reaction', 'inline_link_clicks', 'action:post_engagement', 'unique_outbound_clicks:outbound_click', 'cost_per_action_type:post_engagement', 'ctr', 'cost_per_unique_click', 'action:landing_page_view', 'unique_actions:landing_page_view', 'action:offsite_conversion.custom.281094269070676', 'cost_per_action_type:page_engagement', 'cost_per_unique_action_type:page_engagement', 'device_platform', 'action:offsite_conversion.custom.280669215754025', 'cost_per_unique_action_type:link_click', 'website_ctr:link_click', 'cpc', 'unique_actions:link_click', 'unique_actions:page_engagement', 'date_stop', 'unique_inline_link_clicks', 'cost_per_action_type:link_click', 'inline_post_engagement', 'unique_inline_link_click_ctr', 'cost_per_unique_action_type:landing_page_view', 'unique_link_clicks_ctr', 'action:page_engagement', 'cost_per_inline_post_engagement', 'action:link_click', 'cost_per_outbound_click:outbound_click', 'unique_ctr', 'cost_per_action_type:offsite_conversion.custom.280669215754025', 'impressions', 'unique_actions:post_engagement', 'cost_per_unique_action_type:post_engagement', 'inline_link_click_ctr', 'cost_per_action_type:landing_page_view', 'cost_per_action_type:offsite_conversion.custom.281094269070676', 'clicks', 'cost_per_unique_inline_link_click', 'outbound_clicks:outbound_click', 'date_start', 'instant_experience_clicks_to_open', 'unique_clicks', 'cost_per_unique_outbound_click:outbound_click', 'frequency', 'instant_experience_outbound_clicks', 'outbound_clicks_ctr:outbound_click', 'unique_outbound_clicks_ctr:outbound_click', 'spend', 'cpp', 'instant_experience_clicks_to_start', 'cpm', 'objective', 'cost_per_inline_link_click' ] for x in range(1, 8): date1 = today - datetime.timedelta(days=x) date1 = str(date1) arr = date1.split("-") year = arr[0] month = arr[1] params = { 'time_range': { 'since': date1, 'until': date1 }, 'breakdowns': ['device_platform'] } fields = [ 'account_name', 'campaign_name', 'campaign_id', 'reach', 'frequency', 'impressions', 'clicks', 'cpm', 'ctr', 'spend', 'actions', 'canvas_avg_view_percent', 'canvas_avg_view_time', 'conversion_rate_ranking', 'conversion_values', 'conversions', 'cost_per_action_type', 'cost_per_conversion', 'cost_per_estimated_ad_recallers', 'cost_per_inline_link_click', 'cost_per_inline_post_engagement', 'cost_per_outbound_click', 'cost_per_thruplay', 'cost_per_unique_action_type', 'cost_per_unique_click', 'cost_per_unique_inline_link_click', 'cost_per_unique_outbound_click', 'cpc', 'cpp', 'engagement_rate_ranking', 'estimated_ad_recall_rate', 'estimated_ad_recallers', 'full_view_impressions', 'full_view_reach', 'inline_link_click_ctr', 'inline_link_clicks', 'inline_post_engagement', 'instant_experience_clicks_to_open', 'instant_experience_clicks_to_start', 'instant_experience_outbound_clicks', 'mobile_app_purchase_roas', 'objective', 'outbound_clicks', 'outbound_clicks_ctr', 'place_page_name', 'quality_ranking', 'social_spend', 'unique_actions', 'unique_clicks', 'unique_ctr', 'unique_inline_link_click_ctr', 'unique_inline_link_clicks', 'unique_link_clicks_ctr', 'unique_outbound_clicks', 'unique_outbound_clicks_ctr', 'video_30_sec_watched_actions', 'video_avg_time_watched_actions', 'video_p100_watched_actions', 'video_p25_watched_actions', 'video_p50_watched_actions', 'video_p75_watched_actions', 'video_p95_watched_actions', 'video_play_actions', 'video_play_curve_actions', 'video_thruplay_watched_actions', 'website_ctr', ] f = open("account_id", "r") #importing the account id from external file acc = f.read() my_account = AdAccount(acc) campaignids = my_account.get_campaigns() #print(campaignids) list_d = [] l = [] y = 0 for i in range(len(campaignids)): #print("loop ran ", i) try: c_id = campaignids[i]["id"] campaign = Campaign(c_id) camp_insights = campaign.get_insights(fields=fields, params=params) j = 0 #print(camp_insights) dic_camp = {} for item in camp_insights: #converting to dictionary dic_camp = dict(item) #print("converted to dictionary") #print(dic_camp) #flattening of data try: for each_action in dic_camp["actions"]: dic_camp[ "action:" + each_action['action_type']] = each_action['value'] del dic_camp["actions"] except KeyError: continue try: for each_action in dic_camp["cost_per_action_type"]: dic_camp[ "cost_per_action_type:" + each_action['action_type']] = each_action['value'] del dic_camp["cost_per_action_type"] except KeyError: continue try: for each_action in dic_camp["cost_per_outbound_click"]: dic_camp[ "cost_per_outbound_click:" + each_action['action_type']] = each_action['value'] del dic_camp["cost_per_outbound_click"] except KeyError: continue try: for each_action in dic_camp["cost_per_unique_action_type"]: dic_camp[ "cost_per_unique_action_type:" + each_action['action_type']] = each_action['value'] del dic_camp["cost_per_unique_action_type"] except KeyError: continue try: for each_action in dic_camp[ "cost_per_unique_outbound_click"]: dic_camp[ "cost_per_unique_outbound_click:" + each_action['action_type']] = each_action['value'] del dic_camp["cost_per_unique_outbound_click"] except KeyError: continue try: for each_action in dic_camp["outbound_clicks"]: dic_camp[ "outbound_clicks:" + each_action['action_type']] = each_action['value'] del dic_camp["outbound_clicks"] except KeyError: continue try: for each_action in dic_camp["outbound_clicks_ctr"]: dic_camp[ "outbound_clicks_ctr:" + each_action['action_type']] = each_action['value'] del dic_camp["outbound_clicks_ctr"] except KeyError: continue try: for each_action in dic_camp["unique_actions"]: dic_camp[ "unique_actions:" + each_action['action_type']] = each_action['value'] del dic_camp["unique_actions"] except KeyError: continue try: for each_action in dic_camp["unique_outbound_clicks"]: dic_camp[ "unique_outbound_clicks:" + each_action['action_type']] = each_action['value'] del dic_camp["unique_outbound_clicks"] except KeyError: continue try: for each_action in dic_camp["unique_outbound_clicks_ctr"]: dic_camp[ "unique_outbound_clicks_ctr:" + each_action['action_type']] = each_action['value'] del dic_camp["unique_outbound_clicks_ctr"] except KeyError: continue try: for each_action in dic_camp["website_ctr"]: dic_camp[ "website_ctr:" + each_action['action_type']] = each_action['value'] del dic_camp["website_ctr"] except KeyError: continue #print(dic_camp) list_d.append(dic_camp) except IndexError: continue if list_d: filename1 = "FacebookAds/landing_device/" + "device_" + date1 + ".csv" filename2 = "FacebookAds/processing_device/csv/" + year + "/" + month + "/" + "publisher_device_" + date1 + ".csv" importtos3.write_to_s3(list_d, fields1, 'paragon-datalake', filename1, filename2) return list_d
def listAllCampaigns(self): my_account = AdAccount(fbid=self.account_id) my_account.remote_read(fields=[Campaign.Field.id, Campaign.Field.name]) return my_account.get_campaigns()
class FacebookExecutor: """ Facebook FacebookExecutor. Arguments: """ def __init__(self): self.client = None self.access_token = None self.account = None self.account_id = None self.pixel_id = None self.set_api_config() def set_api_config(self): """ Loads access_token from FACEBOOK_APPLICATION_CREDENTIALS. """ try: with open(os.environ["FACEBOOK_APPLICATION_CREDENTIALS"]) as facebook_cred: data = json.load(facebook_cred) self.access_token = data["access_token"] except KeyError: raise KeyError("FACEBOOK_APPLICATION_CREDENTIALS env variable needed") self.set_client() def set_client(self): """ Sets self.client using the access token. """ self.client = FacebookAdsApi.init(access_token=self.access_token) def set_account(self, account_id): """ Sets account object """ self.account_id = account_id self.account = AdAccount('act_{}'.format(self.account_id)) logging.info("Initiated AdAccount object for account %s", self.account_id) def set_pixel_id(self, pixel_id): """ Sets the Pixel ID """ self.pixel_id = pixel_id logging.info("Set the pixel_id as %s", self.pixel_id) def get_campaign_insights(self, account_id, fields, start_date, end_date): """ Sets insights from the Facebook Insight API. Parameters: account_id: ID associated to the Facebook Account start_date: The start date end_date: The end date fields: list of field to be fetched start_date/end_date: defines the time range to get insights for (YYYY-mm-dd). """ self.set_account(account_id) out = [] params = { 'effective_status': ['ACTIVE'], 'level': 'campaign', 'time_range': { 'since': start_date, 'until': end_date } } logging.debug("Downloading insights for account %s", self.account_id) logging.debug("fields: %s", fields) logging.debug("params: %s", params) campaign_insights = self.account.get_insights( params=params, fields=fields ) for insight in campaign_insights: out.append(dict(insight)) return out def get_active_campaigns(self): return self.account.get_campaigns( fields=['account_id', 'name', 'daily_budget', 'lifetime_budget'], params={ 'effective_status': ["ACTIVE"], 'is_completed': False } ) def get_active_campaign_budgets(self, account_id): """ Fetches active campaign metadata from the Facebook API. Returns a dataframe with the following fields: - account_id - campaign_id - campaign_name - budget_type (daily_budget or lifetime_budget) - budget amount in account currency """ self.set_account(account_id) campaigns = self.get_active_campaigns() out = transform_campaign_budget(campaigns) return out def update_daily_budget(self, account_id, campaign_id, new_budget): """ Update the budget on the facebook API """ self.set_account(account_id) campaigns = self.get_active_campaigns() for campaign in campaigns: if campaign.get_id() == campaign_id: from pygyver.etl.toolkit import configure_logging configure_logging() logging.info( "Loading new budget for campaign %s", campaign_id ) logging.info( "Current daily_budget for campaign %s: %s", campaign_id, campaign['daily_budget'] ) campaign.api_update( params={'daily_budget': round(new_budget*100)} ) logging.info( "New daily_budget for campaign %s: %s", campaign_id, new_budget ) return campaigns def push_conversions_api_events(self, events, test_event_code=None): """ Pushes a list of Events to the Facebook Conversions API. :param events: A list of Facebook Events to push to the conversions API :type events: list of Event :param test_event_code: A test_event_code from Facebook Events Manager to mark these as test events :type test_event_code: str Returns: A dictionary with the parsed response from the Facebook API rtype: dict[str, str] """ if len(events) > 1000: logging.error("The maximum number of events that Facebook accepts in a single API call is 1,000. " "Please use the split_events_to_batches() function to split the events into batches") raise ValueError event_request = EventRequest( events=events, pixel_id=self.pixel_id, ) # Add the test_event_code if one is given if test_event_code: event_request.test_event_code = test_event_code api_response = {} try: event_response = event_request.execute() logging.info('%s events pushed to Facebook Conversions API', event_response.events_received) api_response['status'] = 'API Success' api_response['fb_trace_id'] = event_response.fbtrace_id api_response['messages'] = '\n'.join(event_response.messages) api_response['total_events'] = event_response.events_received except FacebookRequestError as e: logging.error('There was a Facebook Conversions API error:\n\t%s', e) api_response['status'] = 'API Error' api_response['fb_trace_id'] = e.body()['error']['fbtrace_id'] error_message = e.body()['error']['message'] error_message = ': '.join([error_message, e.body()['error']['error_user_msg']]) api_response['messages'] = error_message api_response['total_events'] = None return api_response
def get_list_campaign(account_ids): my_account = AdAccount(account_ids) campaign = my_account.get_campaigns() return campaign
def handle(self, *args, **kwargs): FacebookAdsApi.set_default_api(api) # print('\n\n\n********** Reading objects example. **********\n') # Pro tip: Use list(me.get_ad_accounts()) to make a list out of # all the elements out of the iterator business_account = AdAccount(config['act_id']) business_account.remote_read(fields=[AdAccount.Field.tos_accepted]) camp = business_account.get_campaigns() # for attr, value in camp.__dict__.items(): # print(attr, 'campaign_name') for campaign in camp: get_camp_insights = campaign.get_insights(fields=[ 'campaign_name', 'impressions', 'clicks', 'unique_clicks', 'actions', 'spend', 'cpm', ]) # print("Testing "+str(get_camp_insights)) if (bool(get_camp_insights) == True): client = get_camp_insights[0]['campaign_name'] # print(get_camp_insights) imp_ressions = get_camp_insights[0]['impressions'] spend = get_camp_insights[0]['spend'] date_start = get_camp_insights[0]['date_start'] date_stop = get_camp_insights[0]['date_stop'] client = client.replace(' - ', '@@') split_array = client.split('@@') damo = date.today() bill_month = '{:02}'.format(damo.month) bill_year = '{:04}'.format(damo.year) bill_date = '0' for value in split_array: if 'BD' in value: if len(value) == 3 or len(value) == 4: bill_date = value.replace('BD', '') # bill_date = bill_year+'-'+bill_month+'-'+bill_date if bill_month == '02' and bill_date > '28': bill_date = '28' bill_date = bill_year + '-' + bill_month + '-' + bill_date else: continue if split_array[0][1:5] == 'TEST': client_id = '9876' else: client_id = (re.findall(r'\d+', client.split('@@')[0])[0]) client_name = (client.split('@@')[0].split('] ')[1].strip()) try: if 'for ' in client: target_impressions = int( (re.findall(r'\d+', client.split('for ')[1])[0])) else: target_impressions = int( (re.findall(r'\d+', client.split('@@')[1])[0])) except: target_impressions = 0 status = 'na' days = (datetime.now().date() - datetime.strptime(bill_date, "%Y-%m-%d").date()).days if days < 0: bill_datea = datetime.strptime(bill_date, "%Y-%m-%d") bill_dateaa = bill_datea + relativedelta(months=-1) days = (datetime.now() - bill_dateaa).days days_range_dict = { 15: 10, 16: 20, 17: 30, 18: 40, 19: 50, 20: 60, 21: 70, 22: 80, 23: 90, 24: 100 } if target_impressions > 0: get_percent = (int(imp_ressions) / target_impressions) * 100 #print(days_range_dict) if get_percent > 250: status = 'co' elif get_percent >= 120 and get_percent <= 250: status = 'ov' elif days > 17 and days < 25: if get_percent < 120 and days > 14 and days < 25: if (days_range_dict[days]): status = 'ot' else: status = 'cu' else: status = 'cu' elif get_percent < 120 and days > 14 and days < 25: if (days_range_dict[days]): status = 'ot' elif days > 14 and days < 18: if (days_range_dict[days]): status = 'un' elif days > 9 and days < 15: if imp_ressions == 0: status = 'un' else: pass else: get_percent = 0 pass # print(status) app_tag = 'resultli' data = { 'spend': spend, 'target_impressions': target_impressions, 'date_start': date_start, 'date_stop': date_stop, 'impressions': imp_ressions, 'client_id': client_id, 'client_name': client_name, 'bill_date': bill_date, 'percentage': get_percent, 'status': status, 'app_tag': app_tag, 'days': days } print(data)
# r = requests.get('http://213.162.241.217/fb_bidmod/json_accounts.php') # data = json.loads(r.text.encode('utf-8')) for cu_data in data: act_cid = "act_" + cu_data['cid'] print("act_" + cu_data['cid']) if "weather" in cu_data['services']: print("found weather api") account = AdAccount(act_cid) campaigns = account.get_campaigns(fields=[ Campaign.Field.name, Campaign.Field.configured_status, ], params={ 'effective_status': ['ACTIVE'], 'filtering': [{'field':'name', 'operator':'CONTAIN','value':'Weather API'}], #set to SUMMER }) for i in campaigns: c_value = campaigns temp_campaign = Campaign(i["id"]) campaign_name = i["name"] print(temp_campaign, " campaing id") temp_campaign_str = i["id"] adsets = temp_campaign.get_ad_sets(fields=[ AdSet.Field.name, AdSet.Field.id,
def get_campaigns(app_id: str, app_secret: str, account_access_token: str, account_id: str): FacebookAdsApi.init(app_id, app_secret, account_access_token) account = AdAccount(account_id) return account.get_campaigns()
def data(): my_access_token = request.form['acctoken'] FacebookAdsApi.init(access_token=my_access_token) adacc = 'act_' + request.form['accid'] my_account = AdAccount(adacc) #getting all fields and removing some fields that are not in the document that produce errors Fields_Campaign = [ attr for attr in dir(Campaign.Field) if not callable(getattr(Campaign.Field, attr)) and not attr.startswith("__") ] Fields_Ad = [ attr for attr in dir(Ad.Field) if not callable(getattr(Ad.Field, attr)) and not attr.startswith("__") ] Fields_AdCreative = [ attr for attr in dir(AdCreative.Field) if not callable(getattr(AdCreative.Field, attr)) and not attr.startswith("__") ] a = ['call_to_action', 'image_file', 'is_dco_internal'] Fields_AdCreative = [i for i in Fields_AdCreative if i not in a] Fields_AdSets = [ attr for attr in dir(AdSet.Field) if not callable(getattr(AdSet.Field, attr)) and not attr.startswith("__") ] b = [ 'line_number', 'rb_prediction_id', 'time_start', 'time_stop', 'topline_id', 'tune_for_category', 'upstream_events', 'full_funnel_exploration_mode', 'daily_imps', 'date_format', 'execution_options', 'campaign_spec' ] Fields_AdSets = [i for i in Fields_AdSets if i not in b] Fields_AdsInsights = [ attr for attr in dir(AdsInsights.Field) if not callable(getattr(AdsInsights.Field, attr)) and not attr.startswith("__") ] c = [ 'dwell_3_sec', 'dwell_5_sec', 'actions_per_impression', 'actions_results', 'activity_recency', 'ad_format_asset', 'age', 'amount_in_catalog_currency', 'app_store_clicks', 'attention_events_per_impression', 'attention_events_unq_per_reach', 'body_asset', 'call_to_action_asset', 'call_to_action_clicks', 'campaign_delivery', 'campaign_end', 'campaign_start', 'cancel_subscription_actions', 'card_views', 'catalog_segment_actions', 'catalog_segment_value_in_catalog_currency', 'catalog_segment_value_mobile_purchase_roas', 'catalog_segment_value_website_purchase_roas', 'conditional_time_spent_ms_over_10s_actions', 'conditional_time_spent_ms_over_15s_actions', 'conditional_time_spent_ms_over_2s_actions', 'conditional_time_spent_ms_over_3s_actions', 'conditional_time_spent_ms_over_6s_actions', 'contact_actions', 'contact_value', 'cost_per_action_result', 'cost_per_completed_video_view', 'cost_per_contact', 'cost_per_customize_product', 'cost_per_donate', 'cost_per_dwell', 'cost_per_dwell_3_sec', 'cost_per_dwell_5_sec', 'cost_per_dwell_7_sec', 'cost_per_find_location', 'cost_per_schedule', 'cost_per_start_trial', 'cost_per_submit_application', 'cost_per_subscribe', 'cost_per_total_action', 'country', 'creative_fingerprint', 'customize_product_actions', 'customize_product_value', 'deduping_1st_source_ratio', 'deduping_2nd_source_ratio', 'deduping_3rd_source_ratio', 'deduping_ratio', 'deeplink_clicks', 'description_asset', 'device_platform', 'dma', 'donate_actions', 'donate_value', 'dwell_3_sec, dwell_5_sec', 'dwell_7_sec', 'dwell_rate', 'earned_impression', 'find_location_actions', 'find_location_value', 'frequency_value', 'gender', 'hourly_stats_aggregated_by_advertiser_time_zone', 'hourly_stats_aggregated_by_audience_time_zone', 'image_asset', 'impression_device', 'impressions_auto_refresh', 'impressions_gross', 'link_url_asset', 'media_asset', 'newsfeed_avg_position', 'newsfeed_clicks', 'newsfeed_impressions', 'optimization_goal', 'performance_indicator', 'place_page_id', 'placement', 'platform_position', 'product_id', 'publisher_platform', 'recurring_subscription_payment_actions', 'region', 'rule_asset', 'schedule_actions', 'schedule_value', 'start_trial_actions', 'start_trial_value', 'submit_application_actions', 'submit_application_value', 'subscribe_actions', 'subscribe_value', 'thumb_stops', 'title_asset', 'today_spend', 'total_action_value', 'total_actions', 'total_unique_actions', 'unique_impressions', 'video_asset', 'video_complete_watched_actions', 'video_completed_view_or_15s_passed_actions', 'website_clicks' ] Fields_AdsInsights = [i for i in Fields_AdsInsights if i not in c] #get data from campaigns to ads insights alldata = [] campaign = my_account.get_campaigns(fields=Fields_Campaign) # ad_Creative = my_account.get_ad_creatives(fields =Fields_AdCreative) # ads = my_account.get_ads(fields=Fields_Ad) # ad_sets = my_account.get_ad_sets(fields=Fields_AdSets) # ad_insight = my_account.get_insights(fields = Fields_AdsInsights) alldata.append(campaign) # alldata.push(ad_Creative) # alldata.append(ads) # alldata.push(ad_sets) # alldata.append(ad_insight) return render_template("data.html", data=alldata)
def deleteAllCampaigns(self): my_account = AdAccount(fbid=self.account_id) my_account.remote_read() for c in my_account.get_campaigns(): c.remote_delete()
class FacebookReporter: def __init__(self): app_id = '769583813938024' app_secret = '0d785a6bb23bc248a827fed820fe4ea0' access_token = 'EAAK77rHay2gBANEqlTi1DEbX7oDnyGbu9d3crWlPTHDHeeRL32WtPAPW0yn3cafTw98VXaTpwBZCubl20jRijqZBZCANU9RtMKdJWoYkXRZChW0IFEvJmBw7YrybTFsrnoKH3JvYZBGZAeuRYNMs4Agb2bsO1aeCGFVk3YlqjehRDAKqkXPEuZA' self.facebook_api = FacebookAdsApi.init(app_id, app_secret, access_token) self.ad_account = AdAccount('act_881123992711859') self.fields = [ 'video_play_actions', 'video_p25_watched_actions', 'video_p50_watched_actions', 'video_p75_watched_actions', 'video_p100_watched_actions', 'attribution_setting', 'objective', 'reach', 'impressions', 'frequency', 'account_currency', 'campaign_id', 'campaign_name', 'adset_name', 'adset_id', 'ad_name', 'ad_id', 'ad_impression_actions', 'spend', 'unique_inline_link_clicks', 'actions' ] self.params = { 'level': 'ad', 'date_preset': 'last_30d', 'time_increment': 1, 'use_unified_attribution_setting': True, 'default_summary': True, } self.current_ads = [] def get_ad_data_or_sleep(self, ad): """ Get needed data for ads or sleep :param ad: :return: """ while True: ad_data = {'ad_id': ad} try: ad = Ad(ad) creative = AdCreative( ad.api_get(fields=[Ad.Field.creative])['creative']['id']) fields = [ AdCreative.Field.call_to_action_type, AdCreative.Field.object_story_spec ] creative.api_get(fields=fields) creative = dict(creative) try: call_to_action = creative['object_story_spec'][ 'video_data']['call_to_action'] try: print(creative['object_story_spec']['photo_data']) except KeyError: pass ad_data['website_url'] = call_to_action['value']['link'] ad_data['call_to_action_type'] = call_to_action['type'] ad_data['headline'] = creative['object_story_spec'][ 'video_data']['title'] ad_data['description'] = creative['object_story_spec'][ 'video_data']['message'] video = AdVideo(creative['object_story_spec']['video_data'] ['video_id']) ad_data['video_name'] = video.api_get( fields=[AdVideo.Field.title])['title'] except KeyError: pass self.current_ads.append(ad_data) except FacebookRequestError as e: print(type(e.api_error_code())) if e.api_error_code() == 803: break print('Sleeping right now for ads') time.sleep(600) else: break return ad_data def get_insights_or_sleep(self, campaign): """ Collect insights for campaign or sleep for time to not trigger Facebook API limits :param campaign: :return: """ while True: try: insights = campaign.get_insights(fields=self.fields, params=self.params, is_async=True) insights.api_get() while insights[ AdReportRun.Field. async_status] != 'Job Completed' or insights[ AdReportRun.Field.async_percent_completion] < 100: time.sleep(1) insights.api_get() print(insights[AdReportRun.Field.async_percent_completion]) time.sleep(1) insights = insights.get_result() except FacebookRequestError: print('Sleeping right now for insights') time.sleep(600) else: break return insights def get_campaigns_or_sleep(self): while True: try: campaigns = self.ad_account.get_campaigns() except FacebookRequestError: print('Sleeping right now for campaigns') time.sleep(30) else: break return campaigns def generate_report(self, breakdowns): rows = [] campaigns = [] for campaign in self.get_campaigns_or_sleep(): campaigns.append(campaign) for i in range(len(campaigns)): self.params['breakdowns'] = breakdowns insights = self.get_insights_or_sleep(campaigns[i]) for y in range(len(insights)): insight = dict(insights[y]) flag = False for ad in self.current_ads: if ad['ad_id'] == insight['ad_id']: insight.update(ad) flag = True break if not flag: insight.update(self.get_ad_data_or_sleep(insight['ad_id'])) rows.append(insight) print( f'Pulling dats for campaign, {i}/{len(campaigns)}, {y}/{len(insights)}' ) try: json.dumps(rows) except: rows.remove(insight) CSVGenerator().generate_report(rows, breakdowns)
""" from facebook_business.api import FacebookAdsApi from facebook_business.adobjects.adaccount import AdAccount #Claves de acceso my_app_id = '276686046355294' my_app_secret = '888a472886359feee3c0c0e45b414c00' my_access_token = 'EAAD7pP2B314BAMKHIBTjpPQqXKYOZArD5v7ZBvGbuZAgNNE1YKsqj3iYZAYm2LowacK8NkHOh2eEZCXhhafRvBXk20Um4ZBMn26DVXA5hDoBhQSXn6xJjWhnA9jm85q7sih7sT7WokUI2fLzUm4Xa6n5hpipZASZAF1BwEp8BXCY6PJzdnWoK6ZB1DkT6fBqzyZBmZBvyzINaFgowZDZD' #Iniciar API FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) #Llamadas my_account = AdAccount('act_754103418273978') campaigns = my_account.get_campaigns() print(campaigns) import requests a = requests.get( "https://graph.facebook.com/276686046355294/720786428006108/adnetworkanalytics/?metrics=['fb_ad_network_imp']&access_token=EAAD7pP2B314BAMKHIBTjpPQqXKYOZArD5v7ZBvGbuZAgNNE1YKsqj3iYZAYm2LowacK8NkHOh2eEZCXhhafRvBXk20Um4ZBMn26DVXA5hDoBhQSXn6xJjWhnA9jm85q7sih7sT7WokUI2fLzUm4Xa6n5hpipZASZAF1BwEp8BXCY6PJzdnWoK6ZB1DkT6fBqzyZBmZBvyzINaFgowZDZD" ) a base = a.content type(base) #Llamadas Interesess
class LibFacebook: def __init__(self, app_id, app_secret, access_token, ad_account_id): FacebookAdsApi.init(app_id, app_secret, access_token) self.account = AdAccount(ad_account_id) def create_ad_tree(self): # Campaign fields fields = ["id", "account_id", "adlabels", "bid_strategy", "boosted_object_id", "brand_lift_studies", "budget_rebalance_flag", "budget_remaining", "buying_type", "can_create_brand_lift_study", "can_use_spend_cap", "configured_status", "created_time", "daily_budget", "effective_status", "issues_info", "lifetime_budget", "name", "objective", "recommendations", "source_campaign", "source_campaign_id", "spend_cap", "start_time", "status", "stop_time", "updated_time"] # List of all campaigns campaigns = self.account.get_campaigns(fields=fields) # Ad set fields fields = ["id", "account_id", "adlabels", "adset_schedule", "attribution_spec", "bid_amount", "bid_info", "bid_strategy", "billing_event", "budget_remaining", "campaign", "campaign_id", "configured_status", "created_time", "creative_sequence", "daily_budget", "daily_min_spend_target", "daily_spend_cap", "destination_type", "effective_status", "end_time", "frequency_control_specs", "instagram_actor_id", "is_dynamic_creative", "issues_info", "lifetime_budget", "lifetime_imps", "lifetime_min_spend_target", "lifetime_spend_cap", "name", "optimization_goal", "pacing_type", "promoted_object", "recommendations", "recurring_budget_semantics", "rf_prediction_id", "source_adset", "source_adset_id", "start_time", "status", "targeting", "time_based_ad_rotation_id_blocks", "time_based_ad_rotation_intervals", "updated_time", "use_new_app_click"] # List of all ad sets ad_sets = self.account.get_ad_sets(fields=fields) # Ad fields fields = ["id", "account_id", "ad_review_feedback", "adlabels", "adset", "adset_id", "bid_amount", "bid_info", "bid_type", "campaign", "campaign_id", "configured_status", "conversion_specs", "created_time", "creative", "effective_status", "issues_info", "last_updated_by_app_id", "name", "recommendations", "source_ad", "status", "tracking_specs", "updated_time"] # List of all ads ads = self.account.get_ads(fields=fields) ad_tree = [] for i in campaigns: ad_structure_dict = {"campaign": i.export_all_data(), "adset_list": []} a = 0 for j in ad_sets: if j["campaign_id"] == i["id"]: ad_structure_dict["adset_list"].append({"ad_set": j.export_all_data(), "ad_list": []}) for k in ads: if k["adset_id"] == j["id"]: ad_structure_dict["adset_list"][a]["ad_list"].append({"ad": k.export_all_data()}) a += 1 ad_tree.append(ad_structure_dict) return ad_tree