def __init__(self, account_id): prefs = Preferences.objects.get() ad_account_id = 'act_%s' % account_id FacebookAdsApi.init(access_token=prefs.facebook_access_token) fields = [ 'account_id', 'account_name', 'cost_per_total_action', 'impressions', 'total_action_value', 'spend', ] now = timezone.now() last_day = calendar.monthrange(now.year, now.month)[1] params = { 'time_range': { 'since': now.strftime('%Y-%m-01'), 'until': now.strftime('%Y-%m-') + '%s' % last_day }, 'filtering': [], 'level': 'account', 'breakdowns': [], } try: self.data = AdAccount(ad_account_id).get_insights(fields=fields, params=params)[0] except: self.data = None
def reset_thread_state(**kwargs): ''' Called to reset static variables for example the API instance after we are done with one request to prevent them from unintentionally lingering between requests. ''' FacebookAdsApi.set_default_api(None)
def __init__(self, post): self.ad_account_id = "act_" + post["fb_ad_account"] self.post = post FacebookAdsApi.init(app_id=app_id, app_secret=app_secret, access_token=post["access_token"], api_version="v3.0")
def data(request): print(request) # environmental variables for facebook auth app_id = os.environ['APP_ID'] app_secret = os.environ['APP_SECRET'] access_token = os.environ['ACCESS_TOKEN'] FacebookAdsApi.init(app_id, app_secret, access_token) campaign_id = request.GET['campaign-id'] def get_campaign_stats(campaign): campaign = Campaign(campaign) params = { 'data_preset': 'lifetime', 'fields': [ Insights.Field.impressions, Insights.Field.unique_clicks, Insights.Field.reach, Insights.Field.cpm, Insights.Field.spend, ] } data_set = campaign.get_insights(params=params) return data_set[0] data_set = get_campaign_stats(campaign_id) data_set['cpm'] = str(data_set['cpm'])[:4] context = { 'data_set': data_set, 'name': 'Campaign Breakdown', } print(data_set) return render(request, 'campaigns_data/data.html', context)
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') name = req.params.get('name') if not name: try: req_body = req.get_json() except ValueError: pass else: name = req_body.get('name') token = 'EAAatqMY9YeQBAKo2WiunzO8xaxA0YwqQXfflxCLKuZAZA75i44dndFAYrXP1wwiaDnNElMPy28HalSgz52vI8qkSyW45u8C96o8MZA0hPQU8SA9ZCOhFKoySma4HZAtMR7JLZB262BEY6jDMIEPaKe2P4tTIsdllZBsrmWPyJjCh3of5Tl1hXRZBMG8kZBtM6ViNapBVpbrHw0tSqVPcwe9a9' FacebookAdsApi.init(access_token=token) params = { 'q': name, 'limit': 10000000, 'locate': 'pt_br', 'type': 'adinterest', } name = TargetingSearch.search(params=params) if name: return func.HttpResponse(f"Hello {name}!") else: return func.HttpResponse( "Please pass a name on the query string or in the request body", status_code=400)
def campaigns_with_insights(start, end): response = [] try: my_session = FacebookSession(my_app_id, my_app_secret, my_access_token) my_api = FacebookAdsApi(my_session) FacebookAdsApi.set_default_api(my_api) me = objects.AdUser(fbid='me') my_accounts = list(me.get_ad_accounts()) my_account = my_accounts[0] fields = [ AdsInsights.Field.clicks, AdsInsights.Field.spend, AdsInsights.Field.impressions, AdsInsights.Field.unique_clicks, AdsInsights.Field.cost_per_unique_click, AdsInsights.Field.cost_per_inline_link_click ] params = { 'time_range': { 'since': start, 'until': end }, 'effective_status': ["ACTIVE"] } campaigns = my_account.get_campaigns( params=params, fields=[Campaign.Field.name, Campaign.Field.status]) headers = [ "Name", 'Cost', "Impressions", "Clicks", "Unique Clicks", "Cost per unique click", ] for i in campaigns: try: campaign = Campaign(i['id']) campaign_data = campaign.get_insights(params=params, fields=fields) campaign_dict = { 'id': i['id'], 'name': i['name'], 'Cost': campaign_data[0]['spend'], "Clicks": campaign_data[0]['clicks'], "Unique_Clicks": campaign_data[0]['unique_clicks'], "Cost_per_unique_click": campaign_data[0]['cost_per_unique_click'], "Impressions": campaign_data[0]['impressions'] } response.append(campaign_dict) except: pass except: pass return {'headers': headers, 'rows': response}
def auth(cls): """ Prepare for Ads API calls and return a tuple with act_id and page_id. page_id can be None but act_id is always set. """ config = cls.load_config() if cls._is_authenticated: return config['act_id'], config.get('page_id', None) if config['app_id'] and config['app_secret'] \ and config['act_id'] and config['access_token']: FacebookAdsApi.init( config['app_id'], config['app_secret'], config['access_token'], config['act_id'], ) cls._is_authenticated = True return config['act_id'], config.get('page_id', None) else: required_fields = set( ('app_id', 'app_secret', 'act_id', 'access_token')) missing_fields = required_fields - set(config.keys()) raise FacebookError( '\n\tFile config.json needs to have the following fields: {}\n' '\tMissing fields: {}\n'.format( ', '.join(required_fields), ', '.join(missing_fields), ))
def __init__(self, my_access_token, my_account_id, my_app_id = 'XXXXXXX', my_app_secret='XXXXXXXXXX'): self.my_app_id = my_app_id self.my_app_secret = my_app_secret self.my_access_token = my_access_token self.my_account_id = my_account_id FacebookAdsApi.init(self.my_app_id, self.my_app_secret, self.my_access_token) self.api = FacebookAdsApi.get_default_api()
def getFacebookAPI(token, act_id, secret): token, act_id, secret if secret != '-': api = FacebookAdsApi.init(access_token=token, app_secret=secret) else: api = FacebookAdsApi.init(access_token=token) return api
def get_insights(insight_id=None, timerange=None, fields=None, action_breakdown=False, service=None): if service: FacebookAdsApi.init(service["app_id"], service["app_secret"], service["access_token"]) if not timerange: today = datetime.datetime.now() timerange = { "since": (today - datetime.timedelta(days=7)).strftime("%Y-%m-%d"), "until": today.strftime("%Y-%m-%d") } if not fields: fields = ("call_to_action_clicks,canvas_avg_view_percent," + "impressions,social_clicks,website_clicks,ctr").split(",") params = { 'time_range': timerange, } if action_breakdown: params['action_breakdown'] = 'action_type' else: params['time_increment'] = '1' cdata = None if insight_id.startswith("account/"): cdata = get_account_insights(insight_id[8:], fields, params) if insight_id.startswith("campaign/"): cdata = get_campaign_insights(insight_id[9:], fields, params) if insight_id.startswith("adset/"): cdata = get_adset_insights(insight_id[6:], fields, params) if insight_id.startswith("ad/"): cdata = get_ad_insights(insight_id[3:], fields, params) if not cdata: return {} data = None if action_breakdown: data = {} dt = cdata[0] for f in fields: name = ID_TO_NAME.get(f, f) data[name] = dt[f] else: data = [] for f in fields: v = [] for cd in cdata: date = cd["date_start"] v.append([date, cd[f]]) name = ID_TO_NAME.get(f, f) data.append({'name': name, 'values': v}) return data
def api_boot(credentials): """Function initializing the API connection to Facebook Ads API.""" application_id = credentials['facebook_ads']['app_id'] secret = credentials['facebook_ads']['app_secret'] token = credentials['facebook_ads']['access_token'] FacebookAdsApi.init(application_id, secret, token) print("Facebook Ads API connection successfully initialized.")
def download_data(): """Initializes the FacebookAdsAPI, retrieves the ad accounts and downloads the data""" logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') FacebookAdsApi.init(config.app_id(), config.app_secret(), config.access_token()) ad_accounts = _get_ad_accounts() download_data_sets(ad_accounts)
def get_ad_account(): if secret != '-': FacebookAdsApi.init(access_token=token, app_secret=secret, api_version='v4.0') else: FacebookAdsApi.init(access_token=token, api_version='v4.0') account = AdAccount('act_' + act_id) return account
def facebook_get_service(config): ''' Connects to Facebook Ads platform ''' session = FacebookSession(config['app_id'], config['app_secret'], config['access_token']) api = FacebookAdsApi(session) FacebookAdsApi.set_default_api(api) FacebookAdsApi.init(config['app_id'], config['app_secret'], config['access_token'])
def getfacebookApi(self): if self.secret != '-': self.api = FacebookAdsApi.init(access_token=self.token, app_secret=self.secret, api_version='v3.2') else: self.api = FacebookAdsApi.init(access_token=self.token, api_version='v3.2') self.account = AdAccount('act_' + act_id)
def _deco(*args, **kwargs): access_token = None try: body = json.loads(args[3].decode()) access_token = body.get('access_token') except Exception as ex: access_token = conf.facebook.access_token finally: FacebookAdsApi.init(conf.facebook.app_id, conf.facebook.app_secret, access_token) func(*args, **kwargs)
def init(cls, app_id=None, app_secret=None, access_token=None, account_id=None, api_version=None, pool_maxsize=10, max_retries=0): # connection pool size is +1 because there also is the main thread that can also issue a request session = FacebookSession(app_id, app_secret, access_token, pool_maxsize+1, max_retries) api = cls(session, api_version=api_version, threadpool_size=pool_maxsize) cls.set_default_api(api) # TODO: how to avoid this hack? FacebookAdsApi.set_default_api(api) if account_id: cls.set_default_account_id(account_id)
def insights(start, end): response = {} try: my_session = FacebookSession(my_app_id, my_app_secret, my_access_token) my_api = FacebookAdsApi(my_session) FacebookAdsApi.set_default_api(my_api) me = objects.AdUser(fbid='me') my_accounts = list(me.get_ad_accounts()) my_account = my_accounts[0] fields = [ AdsInsights.Field.clicks, AdsInsights.Field.spend, AdsInsights.Field.impressions, AdsInsights.Field.unique_clicks, AdsInsights.Field.cost_per_unique_click, AdsInsights.Field.cost_per_inline_link_click ] params = { 'time_range': { 'since': start, 'until': end }, } temp = my_account.get_insights(params=params, fields=fields) try: cost_per_click = float(temp[0]['spend']) / float(temp[0]['clicks']) except: cost_per_click = 0 response = [{ 'field': 'Impressions', 'value': temp[0]['impressions'] }, { 'field': 'Cost', 'value': temp[0]['spend'] }, { 'field': 'Clicks', 'value': temp[0]['clicks'] }, { 'field': 'Unique Clicks', 'value': temp[0]['unique_clicks'] }, { 'field': 'Cost per unique click', 'value': temp[0]['cost_per_unique_click'] }, { 'field': 'Cost per Click', 'value': cost_per_click }] except: pass return response
def index(request): #Initialize a new Session and instanciate an Api object my_app_id = '1672585882991034' my_app_secret = '38c9b5fba3cf14297b1da57832c45057' my_access_token = 'CAAXxNT9peboBAG7SNVFXKOm8NillZAQxQLWXIf2N1PZArEpKZCpMTYZCZAGLZBYq0Gdzq7E1l90I7GlIBN2lLpON37JZBzwuADu7iJk7QByBYyeHAsUr62TTiS9wOBkd9JezaZCZCZB6MnSizo5VftYYVnt5rjQ1gDmTgALKIoPxPZC560jJij88hsvXFu64xaiDjnWTFWqSZAiIPwZDZD' FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) #Add after FacebookAdsApi.init me = AdUser(fbid='me') my_account = me.get_ad_accounts()[0] print my_account return HttpResponse('Hello from Python!')
def crawlDemographics(output_file_path, sleep_time): country = 'US' destination_file_path = '%s%s/' % (output_file_path, country) verifyDir(destination_file_path) print destination_file_path log_file = open('%slog_all.txt' % (destination_file_path), 'w') exception_log_file = open( '%sexception_log_all.txt' % (destination_file_path), 'w') if secret != '-': FacebookAdsApi.init(access_token=token, app_secret=secret, api_version='v3.1') else: FacebookAdsApi.init(access_token=token, api_version='v3.1') account = AdAccount('act_' + act_id) count_total_requests = 0 count_interest_ids = 0 count_exceptions = 0 count_sequenced_exceptions = 0 cur_time = getCurrentTime() log_file.write('Execution initialized: %s \n' % cur_time) count_interest_ids += 1 #first element of the following list indicates to the crawler to collect the demographics for the US only whereas second and third one are # the interests related to the new york times and washington post, respectively. list_of_interests = ['all_%s' % cur_time, '6003058819532', '6003096798132'] for interest_id in list_of_interests: # interest_id = 'all_%s' % cur_time # crawlInterest(interest_id, destination_file_path, account, log_file, exception_log_file, sleep_time) count_total_requests, count_sequenced_exceptions, count_exceptions = crawlInterest( interest_id, destination_file_path, account, log_file, exception_log_file, count_total_requests, count_sequenced_exceptions, count_exceptions, sleep_time) if count_sequenced_exceptions == MAXIMUM_EXCEPTIONS: log_file.write('******** Sequenced exceptions == %d **********\n' % MAXIMUM_EXCEPTIONS) log_file.write('******** Going to terminate **********\n') break log_file.write('total of interest ids: %d \n' % count_interest_ids) log_file.write('total of requests: %d \n' % count_total_requests) log_file.write('total of exceptions: %d \n' % count_exceptions) log_file.write('Execution finalized: %s \n' % getCurrentTime()) # # safe exit log_file.close()
def request_new_fb_pixel(): from facebookads.api import FacebookAdsApi from facebookads.objects import AdsPixel, AdUser FacebookAdsApi.init( app.config['FB_MY_APP_ID'], app.config['FB_MY_APP_SECRET'], app.config['FB_MY_ACCESS_TOKEN'] ) me = AdUser(fbid='me') account = me.get_ad_accounts()[0] pixel = account.get_ads_pixels([AdsPixel.Field.code]) return pixel.get_id(), pixel['code'].decode("utf-8")
def download_data(): """Initializes the FacebookAdsAPI, retrieves the ad accounts and downloads the data""" logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') FacebookAdsApi.init(config.app_id(), config.app_secret(), config.access_token()) ad_accounts = _get_ad_accounts() target_accounts = list(filter(None, config.target_accounts().split(','))) if len(target_accounts) > 0: logging.info('the app can see %s accounts but the configuration specified only %s target accounts: %s', len(ad_accounts), len(target_accounts), ', '.join(target_accounts)) ad_accounts = [ad_account for ad_account in ad_accounts if ad_account['account_id'] in config.target_accounts()] logging.info('after filtering %s accounts will be downloaded: %s', len(target_accounts), ', '.join(target_accounts)) download_data_sets(ad_accounts)
def webhook(request): print(request.method) print(request.GET) print(request.POST) print(request.body) challenge = request.GET.get("hub.challenge", "") token = request.GET.get("hub.verify_token", "") mode = request.GET.get('hub.mode', "") msg = 'you are an error!' if token == 'abc1234': return HttpResponse(challenge) leadgen_id = '0007' page = None try: body_unicode = request.body.decode('utf-8') body = json.loads(body_unicode) entry = body['entry'][0]['changes'][0]['value'] ad_id = entry['ad_id'] form_id = entry['form_id'] leadgen_id = entry['leadgen_id'] created_time = entry['created_time'] page_id = entry['page_id'] adgroup_id = entry['adgroup_id'] # TODO FB recognize LeadGen my_app_id = settings.FB_APP_ID my_app_secret = settings.FB_APP_SECRET my_access_token = settings.FB_APP_ACCESS_TOKEN FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) fields = [] params = {} page = models.Page.objects.get(page_id=page_id) fb_lead = Lead(leadgen_id).api_get( fields=fields, params=params, ) lead = models.Lead.create_from_fb_lead(fb_lead, page) msg = 'lead saved!' except Exception as e: models.Lead.objects.create(leadgen_id=leadgen_id, page=page) print('%s (%s)' % (str(e), type(e))) msg = 'lead did not saved :(' return HttpResponse(msg)
def get_fb_data(AccountId): FacebookAdsApi.init(facebookConfig.Configs['App_id'], facebookConfig.Configs['App_secret'], facebookConfig.Configs['Access_token']) my_account = AdAccount(facebookConfig.Accounts[AccountId]) # Grab insight info for all ads in the adaccount #Ever this function will get data from yesterday #If somebody wants to change the range of date, is necessary to change the param 'date_preset' #You can change the level of your request. example: ad, adset or campaign ''' I dont recommend change the param date_preset because the data comes cumulative, not good for me. The data from yesterday is better and trustworthy . I suggest to compare with reports from your Business manager facebook ''' data = my_account.get_insights( params={ 'date_preset': 'yesterday', 'level': 'ad' }, fields=[ AdsInsights.Field.account_id, AdsInsights.Field.account_name, #AdsInsights.Field.campaign_id, AdsInsights.Field.campaign_name, AdsInsights.Field.ad_name, AdsInsights.Field.ad_id, AdsInsights.Field.adset_id, AdsInsights.Field.adset_name, AdsInsights.Field.cost_per_outbound_click, AdsInsights.Field.outbound_clicks, AdsInsights.Field.spend, AdsInsights.Field.clicks, AdsInsights.Field.inline_link_clicks, AdsInsights.Field.inline_link_click_ctr, AdsInsights.Field.cpm, AdsInsights.Field.ctr, AdsInsights.Field.reach, AdsInsights.Field.frequency, AdsInsights.Field.impressions ]) dataNormalize = normalize.dumps_data(data) df = normalize.change_types(dataNormalize) return df
def search(cls, params=None, api=None): api = api or FacebookAdsApi.get_default_api() if not api: raise FacebookBadObjectError( "An Api instance must be provided as an argument or set as " "the default Api in FacebookAdsApi.", ) params = {} if not params else params.copy() response = api.call( FacebookAdsApi.HTTP_METHOD_GET, "/".join( (FacebookSession.GRAPH, FacebookAdsApi.API_VERSION, 'search')), params, ).json() ret_val = [] if response: keys = response['data'] # The response object can be either a dictionary of dictionaries # or a dictionary of lists. if isinstance(keys, list): for item in keys: search_obj = TargetingSearch() search_obj.update(item) ret_val.append(search_obj) elif isinstance(keys, dict): for item in keys: search_obj = TargetingSearch() search_obj.update(keys[item]) if keys[item]: ret_val.append(search_obj) return ret_val
def create_video(request): FacebookAdsApi.init(account_id=settings.FACEBOOK_MAIN_AD_ACCOUNT, access_token=settings.FACEBOOK_TEST_TOKEN) ad_video = AdAccount( fbid=settings.FACEBOOK_MAIN_AD_ACCOUNT ).create_ad_video( params={ AdVideo.Field.slideshow_spec: { 'images_urls': [ 'https://www.downtownrochestermn.com/_files/images/sbs15tkssblue[1].png', 'http://d3sdoylwcs36el.cloudfront.net/VEN-virtual-enterprise-network-business-opportunities-small-fish_id799929_size485.jpg', 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQmvDxaUoi9wsAm2H0qvdaCn8ISnkqOPSBDojx7WznZLoAMhvW_mjI7Pw' ] } }) return JsonResponse(ad_video.export_all_data(), safe=False)
def test_fb(self): try: config_file = open('./autogen_docs_config.json') except IOError: print("No config file found, skipping docs tests") exit() config = json.load(config_file) my_app_id = config['app_id'] my_app_secret = config['app_secret'] my_access_token = config['access_token'] FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) self.assertIsNotNone(FacebookAdsApi.API_VERSION) me = objects.AdUser(fbid='me') my_accounts = list(me.get_ad_accounts()) self.assertGreater(len(my_accounts), 0, '账号数大于0个') config_file.close()
def get_fb_accounts(request): FacebookAccount.objects.all().delete() try: fb_acc = SocialAccount.objects.get(user_id = request.user.id,provider='facebook') fb_tok = SocialToken.objects.get(account=fb_acc) except: return HttpResponse("error connecting Social Accounts") #setting the user information my_app_id = '1604519246476149' my_app_secret = '5a93aee73f1d2856dd542f53e268e483' my_access_token = fb_tok.token #gets the ad accounts in a single, pre-existing facebook account FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) me = objects.AdUser(fbid='me') my_accounts = list(me.get_ad_accounts()) #does it have ad accounts if len(my_accounts) == 0: return HttpResponse("no Ad Accounts Exist") #important note, facebook allows us to only check upto 25 #accounts, we did the privacy note now just need to check if we can #increase the amount index = 0 for current_account in my_accounts: if index == 25: break index = index + 1 fields=[ AdAccount.Field.account_id, AdAccount.Field.name ] current_account.remote_read(fields=fields) if AdAccount.Field.name == "": pass account_model = FacebookAccount() account_model.account_name = str(current_account[AdAccount.Field.name]) account_model.account_id = str(current_account[AdAccount.Field.account_id]) #account_model.report = report_model if not account_model.account_name == "": account_model.save()
def auth(access_token=None): if sys.__stdin__.isatty(): access_token = access_token or config['access_token'] FacebookAdsApi.init( config['app_id'], config['app_secret'], access_token ) else: raise FacebookError( "\n\n" "## (/ o_o)/ ~ _|___|_ \n" "## bootstrap.auth() should only be used in Python's interactive " "shell. Try: python -i facebookads/bootstrap.py\n" "## Or try using FacebookAdsApi.init()" "\n" )
def get_fb_accounts(request): FacebookAccount.objects.all().delete() try: fb_acc = SocialAccount.objects.get(user_id=request.user.id, provider='facebook') fb_tok = SocialToken.objects.get(account=fb_acc) except: return HttpResponse("error connecting Social Accounts") #setting the user information my_app_id = '' my_app_secret = '' my_access_token = fb_tok.token #gets the ad accounts in a single, pre-existing facebook account FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) me = objects.AdUser(fbid='me') my_accounts = list(me.get_ad_accounts()) #does it have ad accounts if len(my_accounts) == 0: return HttpResponse("no Ad Accounts Exist") #important note, facebook allows us to only check upto 25 #accounts, we did the privacy note now just need to check if we can #increase the amount index = 0 for current_account in my_accounts: if index == 25: break index = index + 1 fields = [AdAccount.Field.account_id, AdAccount.Field.name] current_account.remote_read(fields=fields) if AdAccount.Field.name == "": pass account_model = FacebookAccount() account_model.account_name = str(current_account[AdAccount.Field.name]) account_model.account_id = str( current_account[AdAccount.Field.account_id]) #account_model.report = report_model if not account_model.account_name == "": account_model.save()
def auth(access_token=None): if sys.__stdin__.isatty(): access_token = access_token or config['access_token'] FacebookAdsApi.init( config['app_id'], config['app_secret'], access_token, config['act_id'], ) else: raise FacebookError( "\n\n" "## (/ o_o)/ ~ _|___|_ \n" "## bootstrap.auth() should only be used in Python's interactive " "shell. Try: python -i facebookads/bootstrap.py\n" "## Or try using FacebookAdsApi.init()" "\n")
def hello_world(formId): # Facebook app keys my_app_id = '<YOUR_FB_APP_ID>' my_app_secret = '<YOUR_FB_APP_SECRET>' my_access_token = '<YOUR_FB_APP_ACCESS_TOKEN>' FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) if formId != None: form = LeadgenForm(formId) leads = form.get_leads() email = leads[0]['field_data'][0]['values'][0] name = leads[0]['field_data'][1]['values'][0] result = add_list_member(email,name); return 'Hello,formId: {0}, {1}!'.format(formId,result) return 'hello Fb world'
def setUp(self): fbads_session = FacebookSession( settings.SAMPLE_TEST['APP_ID'], settings.SAMPLE_TEST['APP_SECRET'], settings.SAMPLE_TEST['TOKEN'], ) fbads_api = FacebookAdsApi(fbads_session) FacebookAdsApi.set_default_api(fbads_api) self.account_id = settings.SAMPLE_TEST['ACCOUNT_ID'] self.page_id = settings.SAMPLE_TEST['PAGE_ID'] self.form_id = '436706799859690' # For Lead Ads image_files = [ "adimage0.png", "adimage1.jpg", "adimage2.jpg", "adimage3.jpg" ] self.images = map( lambda image_path: os.path.abspath( os.path.join(os.path.dirname(__file__), image_path)), image_files) self.app_info = { "app_name": "DiDiAds", "appstore_link": "https://play.google.com/store/apps/details?id=com.facebook.se.apac.example.liyuhk.didiadsa", "app_deep_link": "example://detail/1234", "fbapplication_id": "743337925789686", "fbpage_id": "1426815194312958", "fboffsitepixel_id": "null" } self.basic_targeting = { "geo_locations": { "countries": ["US"] }, } self.mobile_targeting = { "geo_locations": { "countries": ["US"] }, "user_os": ["Android"], "device_platforms": ["mobile"], "publisher_platforms": ["facebook"], "facebook_positions": ["feed"], } # Base custom audience id that can be used for creating LALs etc. self.ca_id = "6034234313285"
def facebookMain(fbCred, emails_list): act_id = fbCred['fb_user_id'] user_access_token = fbCred['user_token'] # user_access_token = 'CAAHsB1lutXABADNT3ppqATXZBdUwlfgEViIVlaHl5A14CpZBzoCvWi3qycaVdZAtLPnVFH5QY7EKY1UWYuYzvJptzrFaNcE8OXIOOYVo1hX33h8Ml2M9n5yyd7UJ3PHwOtixi6VgJNJY7sZAYY6b4CwqwCwZAjXir8aKAzmu6GMWZAutDKdSQ482SnawqJRIA7XVgR3K7HGIx1ZA4rOEFra' # Login FacebookAdsApi.init(my_app_id, my_app_secret, user_access_token) ad_account = AdAccount(act_id) ### use this to login as yourself (if loged in on this computer) # me = AdUser(fbid='me') # my_account = me.get_ad_accounts()[0] # Push emails to 3Targeting default list audiences_list = getCustomAudiences(ad_account) my_audiences = findAudienceByName(AUDIENCE_DEFAULT_NAME, audiences_list) if my_audiences: retVal = LoadCustomAudience(my_audiences[0], f=emails_list, datatype='email') else: retVal = CreateCustomAudience(ad_account, AUDIENCE_DEFAULT_NAME, description=AUDIENCE_DEFAULT_DESCRIPTION, f=emails_list, datatype='email') return retVal
def get_by_ids(cls, ids, params=None, fields=None, api=None): api = api or FacebookAdsApi.get_default_api() params = dict(params or {}) cls._assign_fields_to_params(fields, params) params["ids"] = ",".join(map(str, ids)) response = api.call("GET", ["/"], params=params) result = [] for fbid, data in response.json().items(): obj = cls(fbid, api=api) obj._set_data(data) result.append(obj) return result
def generate_record(self): my_app_id = '881513028613192' my_app_secret = '4252ecaa9b6b11ed5d72ddb8fc2528db' my_access_token = 'CAAMhuz7vdEgBAPSuWuBSoCjsV0P45Y3KrqU7y5blqHVyM3XshUN9Dr3ZBNJWZCGJljogD6ZC2XSbqXT4D7I6PVH7isy4EBDqb1U3lB005yIM65ov4fCYUKz3J42kxMfwZBpVZABqBM5vOjZApE6ZC9PvOkRnc7mwZBMFZBnVXBiy37LgJJP2RQrZACpTac2s9INasZD' FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) campaign = Campaign('6029907036952') campaign.remote_read(fields=[ Campaign.Field.name, Campaign.Field.effective_status, Campaign.Field.objective, ]) params = { 'date_preset': 'last_30_days', } insights = campaign.get_insights(params=params) self.write({'name': campaign['name']}) self.write({'result': insights[0]['actions'][0]['value']}) self.write({'reach': insights[0]['reach']}) self.write({'cost': insights[0]['cost_per_total_action']}) self.write({'amount_spent': insights[0]['spend']})
def auth(cls): """ Prepare for Ads API calls and return a tuple with act_id and page_id. page_id can be None but act_id is always set. """ config = cls.load_config() if cls._is_authenticated: return config['act_id'], config.get('page_id', None) if config['app_id'] and config['app_secret'] \ and config['act_id'] and config['access_token']: FacebookAdsApi.init( config['app_id'], config['app_secret'], config['access_token'], config['act_id'], ) cls._is_authenticated = True return config['act_id'], config.get('page_id', None) else: required_fields = set( ('app_id', 'app_secret', 'act_id', 'access_token') ) missing_fields = required_fields - set(config.keys()) raise FacebookError( '\n\tFile config.json needs to have the following fields: {}\n' '\tMissing fields: {}\n'.format( ', '.join(required_fields), ', '.join(missing_fields), ) )
def __init__(self, fbid=None, parent_id=None, api=None): """Initializes a CRUD object. Args: fbid (optional): The id of the object ont the Graph. parent_id (optional): The id of the object's parent. api (optional): An api object which all calls will go through. If an api object is not specified, api calls will revert to going through the default api. """ super(AbstractCrudObject, self).__init__() self._api = api or FacebookAdsApi.get_default_api() self._changes = {} self._parent_id = parent_id self._data['id'] = fbid self._include_summary = True
def __init__(self, fbid=None, parent_id=None, api=None): """Initializes a CRUD object. Args: fbid (optional): The id of the object ont the Graph. parent_id (optional): The id of the object's parent. api (optional): An api object which all calls will go through. If an api object is not specified, api calls will revert to going through the default api. """ super(AbstractCrudObject, self).__init__() self._api = api or FacebookAdsApi.get_default_api() self._changes = {} if (parent_id is not None): warning_message = "parent_id as a parameter of constructor is " \ "being deprecated." logging.warning(warning_message) self._parent_id = parent_id self._data['id'] = fbid self._include_summary = True
def remote_create_from_zip(cls, filename, parent_id, api=None): api = api or FacebookAdsApi.get_default_api() open_file = open(filename, 'rb') response = api.call( 'POST', (parent_id, cls.get_endpoint()), files={filename: open_file}, ) open_file.close() data = response.json() objs = [] for image_filename in data['images']: image = cls(parent_id=parent_id) image.update(data['images'][image_filename]) image[cls.Field.id] = '%s:%s' % ( parent_id[4:], data['images'][image_filename][cls.Field.hash], ) objs.append(image) return objs
def search(cls, params=None, api=None): api = api or FacebookAdsApi.get_default_api() if not api: raise FacebookBadObjectError( "An Api instance must be provided as an argument or set as " "the default Api in FacebookAdsApi.", ) params = {} if not params else params.copy() response = api.call( FacebookAdsApi.HTTP_METHOD_GET, "/".join(( FacebookSession.GRAPH, FacebookAdsApi.API_VERSION, 'search' )), params, ).json() ret_val = [] if response: keys = response['data'] # The response object can be either a dictionary of dictionaries # or a dictionary of lists. if isinstance(keys, list): for item in keys: search_obj = TargetingSearch() search_obj.update(item) ret_val.append(search_obj) elif isinstance(keys, dict): for item in keys: search_obj = TargetingSearch() search_obj.update(keys[item]) if keys[item]: ret_val.append(search_obj) return ret_val
repo_dir = os.path.join(this_dir, os.pardir) sys.path.insert(1, repo_dir) from facebookads.objects import AdAccount, AsyncJob from facebookads.api import FacebookAdsApi import time import os import json this_dir = os.path.dirname(__file__) config_filename = os.path.join(this_dir, 'config.json') config_file = open(config_filename) config = json.load(config_file) config_file.close() api = FacebookAdsApi.init(access_token=config['access_token']) account_id = config['act_id'] account = AdAccount(account_id) # Both Insights and Reportstats i_async_job = account.get_insights(params={'level': 'ad'}, async=True) # Insights while True: job = i_async_job.remote_read() print("Percent done: " + str(job[AsyncJob.Field.async_percent_completion])) time.sleep(1) if job: # print "Done!" break
from __future__ import print_function from __future__ import unicode_literals from facebookads.objects import TargetingSearch from facebookads.api import FacebookAdsApi from facebookads.exceptions import * config_file = open('./examples/docs/config.json') config = json.load(config_file) config_file.close() ad_account_id = config['account_id'] access_token = config['access_token'] app_id = config['app_id'] app_secret = config['app_secret'] FacebookAdsApi.init(app_id, app_secret, access_token) # _DOC open [SEARCH_GEOLOCATION_WITH_COUNTRY] from facebookads.objects import TargetingSearch params = { 'q': 'un', 'type': 'adgeolocation', 'location_types': ['country'], } resp = TargetingSearch.search(params=params) print(resp) # _DOC close [SEARCH_GEOLOCATION_WITH_COUNTRY] # _DOC open [SEARCH_GEOLOCATION_WITH_REGION] from facebookads.objects import TargetingSearch
def month_fb_data(request, account_model): try: fb_acc = SocialAccount.objects.get(user_id = request.user.id,provider='facebook') fb_tok = SocialToken.objects.get(account=fb_acc) except: return HttpResponse("error connecting Social Accounts") #setting the user information my_app_id = '1604519246476149' my_app_secret = '5a93aee73f1d2856dd542f53e268e483' my_access_token = fb_tok.token #gets the ad accounts in a single, pre-existing facebook account FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) me = objects.AdUser(fbid='me') my_accounts = list(me.get_ad_accounts()) #does it have ad accounts if len(my_accounts) == 0: return HttpResponse("no Ad Accounts Exist") #important note, facebook allows us to only check upto 25 #accounts, we did the privacy note now just need to check if we can #increase the amount index = 0 for current_account in my_accounts: if index == 25: break index = index + 1 fields=[ AdAccount.Field.account_id, AdAccount.Field.name ] current_account.remote_read(fields=fields) if account_model.account_name == str(current_account[AdAccount.Field.name]): break ad_campaigns = current_account.get_ad_campaigns() for current_campaign in ad_campaigns: fields=[ AdCampaign.Field.name, AdCampaign.Field.status, AdCampaign.Field.id] params = { 'date_preset': 'last_30_days' } try: current_campaign.remote_read(fields=fields, params=params) except: pass fields = { 'impressions', 'clicks', 'spend' } try: data = str(current_campaign.get_insights(fields=fields,params=params)) except: pass data = '['+data[12:] try: ast.literal_eval(data) json_string = json.dumps(data) parsed_data = json.loads(data) except: continue campaign_model = FacebookCampaign() campaign_model.name = str(current_campaign[AdCampaign.Field.name]) campaign_model.campaign_id = str(current_campaign[AdCampaign.Field.id]) campaign_model.status = str(current_campaign[AdCampaign.Field.status]) campaign_model.clicks = int(parsed_data[0]['clicks']) campaign_model.impressions = int(parsed_data[0]['impressions']) campaign_model.cost = float(parsed_data[0]['spend']) if not campaign_model.impressions == 0: campaign_model.CTR = round(campaign_model.clicks * 100/campaign_model.impressions,2) campaign_model.CPM = round(campaign_model.cost * 1000 / campaign_model.impressions,2) if not campaign_model.clicks == 0: campaign_model.CPC = round(campaign_model.cost/campaign_model.clicks,2) campaign_model.account = account_model campaign_model.save()
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. from facebookads import test_config page_id = test_config.page_id # _DOC oncall [pruno] # _DOC open [PAGE_GET_LOCATIONS] # _DOC vars [page_id] from facebookads.api import FacebookAdsApi response = FacebookAdsApi.get_default_api().call( 'GET', ('/{}/locations'.format(page_id),), { 'fields': 'location', }).json() for location in response['data']: print("{},{}\n".format( location['location']['latitude'], location['location']['longitude'], )) # _DOC close [PAGE_GET_LOCATIONS]
def get_parent_id(self): """Returns the object's parent's id.""" return self._parent_id or FacebookAdsApi.get_default_account_id()
# of this software is subject to the Facebook Developer Principles and # Policies [http://developers.facebook.com/policy/]. This copyright notice # shall be included in all copies or substantial portions of the software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. from facebookads import test_config page_id = test_config.page_id # _DOC oncall [pruno] # _DOC open [PAGE_CHECK_LOCATIONS] # _DOC vars [page_id] from facebookads.api import FacebookAdsApi response = FacebookAdsApi.get_default_api().call( 'GET', ('/{}/locations'.format(page_id),), { 'limit': 1, }).json() has_locations = len(response['data']) > 0 # _DOC close [PAGE_CHECK_LOCATIONS]
this_dir = os.path.dirname(__file__) config_filename = os.path.join(this_dir, os.pardir, os.pardir, 'config.json') import sys sys.path.insert(1, os.path.join(this_dir, os.pardir, os.pardir)) config_file = open(config_filename) config = json.load(config_file) config_file.close() from facebookads.api import FacebookAdsApi from facebookads.objects import ProductCatalog, Product FacebookAdsApi.init( config['app_id'], config['app_secret'], config['access_token'], ) if __name__ == '__main__': catalog_id = '<INSERT_YOUR_CATALOG_ID_HERE>' catalog = ProductCatalog(catalog_id) items = [] for line in sys.stdin.readlines(): if line.endswith('\n'): items.append(line[:-1].split(',')) else: items.append(line.split(',')) for item in items:
from facebookads.adobjects.user import User from facebookads.adobjects.page import Page from facebookads.adobjects.pagepost import PagePost from facebookads.adobjects.adaccount import AdAccount from facebookads.adobjects.campaign import Campaign from facebookads.adobjects.adset import AdSet from facebookads.adobjects.adcreative import AdCreative from facebookads.adobjects.ad import Ad from facebookads.api import FacebookAdsApi access_token = '<ACCESS_TOKEN>' app_secret = '<APP_SECRET>' app_id = '<APP_ID>' id = '<ID>' FacebookAdsApi.init(access_token=access_token) # User get fields = [ ] params = { } user = User(id).get( fields=fields, params=params, ) print 'user', user user_id = user.get_id() print 'user_id:', user_id, '\n' # Get page access token and page_id
# Policies [http://developers.facebook.com/policy/]. This copyright notice # shall be included in all copies or substantial portions of the software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. from facebookads.adobjects.adset import AdSet from facebookads.adobjects.adsinsights import AdsInsights from facebookads.api import FacebookAdsApi access_token = '<ACCESS_TOKEN>' app_secret = '<APP_SECRET>' app_id = '<APP_ID>' id = '<ID>' FacebookAdsApi.init(access_token=access_token) fields = [ 'impressions', ] params = { 'breakdown': 'publisher_platform', } print AdSet(id).get_insights( fields=fields, params=params, )
from facebookads.api import FacebookAdsApi from facebookads.objects import AdUser, Campaign, AdAccount, AdSet from facebookads import FacebookSession, FacebookAdsApi, objects import os my_app_id = os.environ['APP_ID'] my_app_secret = os.environ['APP_SECRET'] my_access_token = 'CAAN4vFUE2ZAgBAHaZA6dmP6v4eIxOcV8TtA2crGjLG47ZCEllpjUSUlGFGDIFCX0KQrWBw8OGY9I7vi087ekgpaoldSyaya3HtIJgzC7oR2GQnpE8TfWi8uAB7LqtjMGqtgmvzFXZBTytZCkMDVm9WTC9vBqQZAuxVpj10yyQZC0WigZBaxvKfvG' #Your user access token FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) """ 17 University of Louisville id num: act_1006561952727232 18 Ruffino Canada id num: act_999404050109689 19 Damp Rid id num: act_946663412050420 20 Stoli Canada id num: act_971018509614910 21 Beau tea Bar id num: act_916124548437640 22 Pop Crush id num: act_933960369987391 23 Ravage
def get_report(request): Campaign.objects.all().delete() Account.objects.all().delete() #check if user is authenticated if not request.user.is_authenticated(): return render(request, 'account/login.html') #setting the user information my_app_id = '1604519246476149' my_app_secret = '5a93aee73f1d2856dd542f53e268e483' current_user = SocialAccount.objects.get(user=request.user, provider='facebook') current_token = SocialToken.objects.get(account=current_user) my_access_token = current_token.token FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token) me = objects.AdUser(fbid='me') my_accounts = list(me.get_ad_accounts()) if len(my_accounts) == 0: return HttpResponse("no Ad Accounts Exist") index = 0 for current_account in my_accounts: if index == 5: break index = index + 1 current_account.remote_read(fields=[ AdAccount.Field.account_id, AdAccount.Field.name, AdAccount.Field.amount_spent, ]) account_model = Account() account_model.account_name = str(current_account[AdAccount.Field.name]) account_model.account_id = str(current_account[AdAccount.Field.account_id]) account_model.account_cost = str(float(current_account[AdAccount.Field.amount_spent])/100) account_model.save() ad_campaigns = current_account.get_ad_campaigns() for current_campaign in ad_campaigns: current_campaign.remote_read(fields=[ AdCampaign.Field.name, AdCampaign.Field.status, AdCampaign.Field.id, ]) fields = { 'impressions', 'clicks', 'cpc' } data = str(current_campaign.get_insights(fields=fields)) data = '['+data[12:] try: ast.literal_eval(data) json_string = json.dumps(data) parsed_data = json.loads(data) except: continue campaign_model = Campaign() campaign_model.name = str(current_campaign[AdCampaign.Field.name]) campaign_model.campaign_id = str(current_campaign[AdCampaign.Field.id]) campaign_model.status = str(current_campaign[AdCampaign.Field.status]) campaign_model.clicks = int(parsed_data[0]['clicks']) campaign_model.cpc = float(parsed_data[0]['cpc']) campaign_model.impressions = int(parsed_data[0]['impressions']) campaign_model.account = account_model campaign_model.save() return HttpResponse("Good Humes")