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 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 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 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 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")
