YouTube Reporting API - Data Model

חשוב: שינוי שיבוצע בקרוב במדיניות ישפיע על משך הזמן שבו אפשר לאחזר את דוחות YouTube Reporting API. לאחר השינוי, דוחות ה-API היומיים ודוחות המילוי החוזר יהיו זמינים למשך 60 יום (במקום 180 יום) מהמועד שבו הופקו. דוחות של נתונים היסטוריים יהיו זמינים למשך 30 יום מהמועד שבו הופקו.

השינוי הזה מתוכנן להיכנס לתוקף ביולי 2018, והמדיניות החדשה תחול באופן גלובלי על כל הדוחות ומשימות הדיווח. פרטים נוספים על השינוי זמינים בהיסטוריית הגרסאות של ה-API.

YouTube Reporting API תומך בדוחות מוגדרים מראש שמכילים קבוצה מקיפה של נתונים מ-YouTube Analytics לגבי ערוץ או בעלי תוכן. הדוחות האלה מאפשרים להוריד את קבוצות הנתונים בכמות גדולה שניתן להריץ עליהן שאילתות באמצעות YouTube Analytics API או בקטע Analytics ב-YouTube Studio.

סקירה כללית

שדות הדוחות בדוחות האלה מאופיינים כמאפיינים או כמדדים:

  • מאפיינים הם קריטריונים נפוצים שמשמשים לצבירת נתונים, כמו התאריך שבו התרחשה פעולה או המדינה שבה המשתמשים היו. בכל שורת נתונים בדוח יש שילוב ייחודי של ערכי מאפיינים.
  • מדדים הם מדידות בודדות שקשורות לפעילות משתמשים, לביצועי מודעות או להכנסה משוערת. מדדי פעילות המשתמשים כוללים מידע כמו ספירת צפיות בסרטונים ודירוגים (לייקים ודיסלייקים).

לדוגמה, הדוח הבסיסי של פעילות המשתמש עבור ערוצים כולל את המאפיינים הבאים:

  • date: התאריך שבו התרחשה הפעילות.
  • channel_id: ערוץ YouTube שמשויך לפעילות.
  • video_id: הסרטון ב-YouTube שמשויך לפעילות.
  • live_or_on_demand: הערך הזה שמציין אם הצופים צפו בשידור החי.
  • subscribed_status: ערך שמציין אם הצופים היו מנויים לערוץ.
  • country_code: המדינה שבה נמצאים הצופים.

הדוח מכיל גם הרבה מדדים, כמו צפיות, לייקים ו-average_view_duration_seconds. לאחר אחזור וייבוא הדוח, אפליקציה יכולה לבצע חישובים שונים רבים על סמך ערכי מאפיינים משותפים.

אחזור דוחות של YouTube Analytics

שלב 1: מאחזרים את פרטי הכניסה להרשאה

כל הבקשות של YouTube Reporting API חייבות להיות מאושרות. במדריך ההרשאות מוסבר איך משתמשים בפרוטוקול OAuth 2.0 כדי לאחזר אסימוני הרשאה.

בקשות של YouTube Reporting API משתמשות בהיקפי ההרשאה הבאים:

רמות
https://www.googleapis.com/auth/yt-analytics.readonly עיין בדוחות YouTube Analytics עבור התוכן שלך ב-YouTube. ההיקף הזה נותן גישה למדדי פעילות משתמשים, כמו ספירת צפיות וספירות דירוגים.
https://www.googleapis.com/auth/yt-analytics-monetary.readonly הצג דוחות כספיים של YouTube Analytics עבור התוכן שלך ב-YouTube. ההיקף הזה נותן גישה למדדים של פעילות המשתמשים ולמדדים של ההכנסות המשוערות ושל ביצועי המודעות.

שלב 2: זיהוי הדוח שרוצים לאחזר

מפעילים את השיטה reportTypes.list של ה-API כדי לאחזר רשימה של דוחות שאפשר ליצור עבור הערוץ או בעלי התוכן. השיטה מחזירה רשימה של שמות ומזהים של דוחות. מתעדים את ערך הנכס id בדוחות שרוצים ליצור. לדוגמה, המזהה של דוח פעילות המשתמש הבסיסי לערוצים הוא channel_basic_a1.

תוכלו למצוא את שמות הדוחות גם במסמכי התיעוד שבהם מוגדרים דוחות הערוצים הנתמכים, ודוחות של בעלי התוכן.

שלב 3: יצירה של משימת דיווח

המערכת של YouTube לא תתחיל להפיק את הדוח עד שתיצרו משימת דיווח לדוח. (לכן, הדוחות מופקים רק עבור הערוצים ובעלי התוכן שבאמת רוצים לאחזר אותם).

כדי ליצור משימת דיווח, צריך לקרוא ל-method jobs.create של ה-API. יש להגדיר את הערכים הבאים בגוף הבקשה:

  • מגדירים את הערך של הנכס ב-reportTypeId למזהה הדוח שאחזרתם בשלב 2.
  • מגדירים את הערך של הנכס ב-name לשם שרוצים לשייך לדוח.

תגובת ה-API ל-method jobs.create מכילה משאב Job, שמציין את ID שמזהה את המשימה באופן ייחודי. אפשר להתחיל לאחזר את הדוח תוך 48 שעות מרגע יצירת המשימה, והדוח הזמין הראשון יהיה עבור היום שבו תזמנתם את המשימה.

לדוגמה, אם מתזמנים משרה ב-1 בספטמבר 2015, הדוח של התאריך 1 בספטמבר 2015 יהיה מוכן מ-3 בספטמבר 2015. הדוח ל-2 בספטמבר 2015 יפורסם ב-4 בספטמבר 2015 וכן הלאה.

שלב 4: מאחזרים את מזהה המשרה

הערה: אם באפליקציה מאוחסן מזהה המשימה שהוחזר בשלב 3, אפשר לדלג על השלב הזה.

צריך לבצע קריאה לשיטה jobs.list כדי לאחזר רשימה של משימות מתוזמנות. המאפיין reportTypeId בכל משאב Job שמוחזר מזהה את סוג הדוח שהמשימה יוצרת. האפליקציה שלך צריכה את ערך המאפיין id מאותו משאב בשלב הבא.

שלב 5: מאחזרים את כתובת ה-URL להורדת הדוח

צריך לקרוא לשיטה jobs.reports.list כדי לאחזר רשימה של דוחות שנוצרו עבור המשימה. בבקשה, מגדירים את הפרמטר jobId למזהה המשימה של הדוח שרוצים לאחזר.

טיפ: מומלץ להשתמש בפרמטר createdAfter כדי לציין שה-API צריך להחזיר רק דוחות שנוצרו לאחר זמן מסוים. הפרמטר הזה יכול לשמש כדי לוודא שה-API מחזיר רק דוחות שלא עיבדתם בעבר.

תגובת ה-API מכילה רשימה של Report משאבים למשימה הזו. כל משאב מתייחס לדוח שמכיל נתונים מתקופה ייחודית של 24 שעות. שימו לב: המערכת של YouTube יוצרת דוחות שניתן להוריד עבור הימים שבהם לא היו נתונים זמינים. הדוחות האלה מכילים שורת כותרת, אבל הם לא מכילים נתונים נוספים.

  • המאפיינים startTime ו-endTime של המשאב מזהים את תקופת הזמן שאליה מתייחסים הנתונים בדוח.
  • המאפיין downloadUrl של המשאב מזהה את כתובת ה-URL שממנה ניתן לאחזר את הדוח.

  • המאפיין createTime של המשאב מציין את התאריך והשעה שבהם הדוח נוצר. האפליקציה שלך צריכה לאחסן את הערך הזה ולהשתמש בו כדי לקבוע אם דוחות שהורדו בעבר השתנו.

שלב 6: הורדת הדוח

שולחים בקשת HTTP GET אל downloadUrl שהתקבלה בשלב 5, כדי לאחזר את הדוח.

ניתן להפחית את רוחב הפס הדרוש להורדת דוחות על ידי הפעלה של דחיסת gzip בבקשות הורדה. לאפליקציה נדרש זמן נוסף של המעבד (CPU) כדי לבטל את הדחיסה של תגובות ה-API, אבל היתרון של צריכת משאבי רשת קטן בדרך כלל גבוה יותר מהעלות הזו.

כדי לקבל תגובה בקידוד gzip, יש להגדיר את כותרת בקשת ה-HTTP Accept-Encoding ל-gzip כפי שמוצג בדוגמה הבאה:

Accept-Encoding: gzip

עיבוד דוחות

שיטות מומלצות

אפליקציות שמשתמשות ב-YouTube Reporting API צריכות תמיד לפעול לפי השיטות הבאות:

  • סדר העמודות של הדוח נקבע לפי שורת הכותרת של הדוח. לדוגמה, אל תניחו שצפיות הן המדד הראשון שמוחזר בדוח, רק בגלל שהוא המדד הראשון בתיאור של הדוח. במקום זאת, אפשר להשתמש בשורת הכותרת של הדוח כדי לקבוע איזו עמודה מכילה את הנתונים האלה.

  • מתעדים את הדוחות שהורדתם כדי למנוע עיבוד חוזר של אותו דוח. ברשימה הבאה מוצעות שתי דרכים לעשות זאת.

    • כשמבצעים קריאה לשיטה reports.list, צריך להשתמש בפרמטר createdAfter כדי לאחזר רק דוחות שנוצרו אחרי תאריך מסוים. (השמטת הפרמטר createdAfter בפעם הראשונה שמאחזרים דוחות).

      בכל פעם שמאחזרים ומעבדים דוחות בהצלחה, חשוב לשמור את חותמת הזמן שתואמת לתאריך ולשעה שבהם נוצר הדוחות החדשים ביותר. לאחר מכן, מעדכנים את ערך הפרמטר createdAfter בכל קריאה רציפה ל-method reports.list, כדי לוודא שמאחזרים רק דוחות חדשים, כולל דוחות חדשים עם נתונים שמולאו חוסרים, בכל פעם שמפעילים את ה-API.

      כאמצעי הגנה, לפני אחזור דוח, כדאי לוודא שהמזהה של הדוח לא מופיע כבר במסד הנתונים.

    • לשמור את המזהה של כל דוח שהורדתם ועיבדתם. אפשר גם לשמור מידע נוסף, כמו התאריך והשעה שבהם הופק כל דוח, או startTime ו-endTime של הדוח. הנתונים האלה מזהים יחד את התקופה שבה הדוח מכיל נתונים. שימו לב שלכל משימה כנראה יהיו הרבה דוחות, כי כל דוח מכיל נתונים לתקופה של 24 שעות.

      משתמשים במזהה הדוח כדי לזהות דוחות שעדיין צריך להוריד ולייבא. עם זאת, אם לשני דוחות חדשים יש אותם ערכי נכס startTime ו-endTime, יש לייבא רק את הדוח עם הערך החדש יותר של createTime.

  • הדוחות מכילים מזהים שמשויכים למשאבים של YouTube. אפשר להשתמש ב-YouTube Data API כדי לאחזר מטא-נתונים נוספים של המשאבים האלה. כפי שמצוין במדיניות למפתחים של שירותי YouTube API (סעיפים III.E.4.b עד III.E.4.d), לקוחות API חייבים למחוק או לרענן מטא-נתונים של משאבים מאוחסנים מאותו API לאחר 30 יום.

מאפייני הדוח

דוחות API הם קובצי גרסאות .csv (ערכים מופרדים בפסיקים) עם המאפיינים הבאים:

  • כל דוח מכיל נתונים עבור פרק זמן ייחודי של 24 שעות, שנמשך מ-00:00 עד 23:59 לפי שעון החוף המערבי של ארה"ב. לכן, בכל דוח נתון, ערך המאפיין תאריך תמיד זהה.

  • הדוחות מתעדכנים מדי יום.

  • YouTube יוצר דוחות שניתן להוריד עבור הימים שבהם לא היו נתונים זמינים. הדוחות האלה יכללו שורת כותרת, אבל לא יכילו נתונים נוספים.

  • חשוב: שינוי שיבוצע בקרוב במדיניות ישפיע על משך הזמן שבו אפשר לאחזר את דוחות YouTube Reporting API. נכון לעכשיו, השינוי מתוכנן להיכנס לתוקף ביולי 2018, והוא חל בכל העולם על כל משימות הדיווח והדיווח.

    • לפני השינוי, דוחות ה-API יהיו זמינים למשך עד 180 יום מהמועד שבו הופקו.
    • אחרי השינוי, דוחות ה-API יהיו זמינים למשך 60 יום מהמועד שבו הופקו, חוץ מנתונים היסטוריים שנוצרו למשימות דיווח חדשות. כאשר השינוי במדיניות ייכנס לתוקף, לא תהיה יותר גישה לדוחות שנוצרו לפני יותר מ-60 יום.
    • אחרי השינוי, דוחות שמכילים נתונים היסטוריים יהיו זמינים למשך 30 יום מהמועד שבו הופקו. כאשר השינוי במדיניות ייכנס לתוקף, לא תהיה יותר גישה לדוחות שמכילים נתונים היסטוריים וכבר נוצרו לפני יותר מ-30 יום.
  • נתוני הדוח לא מסוננים. לכן, דוח ערוצים מכיל את כל הנתונים לגבי הסרטונים או הפלייליסטים בערוץ, פרט למקרה חריג שמצוין בפסקה הבאה בנוגע למשאבים שנמחקו. באופן דומה, דוח בעלי תוכן מכיל את כל הנתונים לגבי הערוצים של בעלי התוכן (סרטונים, פלייליסטים, ביצועי מודעות וכו'), פרט למקרים הבאים.

    לא מתבצע סינון של נתוני דוחות, אבל דוחות שמכילים נתונים מ-1 ביוני 2018 או תקופת זמן מסוימת אחרי התאריך הזה לא יכללו הפניות למשאבים ב-YouTube שנמחקו 30 ימים לפחות לפני תאריך יצירת הדוח.

  • הנתונים בדוח לא ממוינים.

  • דוחות לא משמיטים שורות שאין בהן מדדים. במילים אחרות, שורות שאין בהן מדדים לא נכללות בדוח. לדוגמה, אם לסרטון אין צפיות באלבניה ביום מסוים, הדוח של אותו יום לא יכלול שורות לגבי אלבניה.

  • הדוחות לא מכילים שורות עם נתוני סיכום של מדדים, כמו מספר הצפיות הכולל בכל הסרטונים בערוץ. ניתן לחשב את הערכים הכוללים האלה כסכום הערכים בדוח, אבל ייתכן שהסכום הזה לא יכלול מדדים של סרטונים שנמחקו, כפי שצוין למעלה. אפשר גם להשתמש ב-YouTube Analytics API כדי לאחזר את הספירה הכוללת. ה-API של YouTube Analytics מחזיר ערכים כוללים שכוללים מדדים של משאבים שנמחקו, למרות שלא מוזכרים במפורש במשאבים האלה בתגובות של ה-API.

נתונים למילוי חוסרים (backfill)

נתוני מילוי חוסרים (backfill) הם קבוצת נתונים שמחליפה קבוצה שהועברה בעבר. כשדוח נתונים למילוי חוסרים זמין, האפליקציה צריכה לאחזר את הדוח החדש ולעדכן את הנתונים המאוחסנים כך שיתאימו למערך הנתונים המתוקן. לדוגמה, האפליקציה שלכם יכולה למחוק את הנתונים הקודמים עבור התקופה המכוסה בדוח, ולאחר מכן לייבא את קבוצת הנתונים החדשה.

אם קיימים ב-YouTube נתוני מילוי חוסרים, המערכת תיצור דוח חדש עם מזהה דוח חדש. במקרה כזה, ערכי המאפיין startTime ו-endTime בדוח יתאימו לזמני ההתחלה והסיום של דוח שהיה זמין בעבר ושהורדתם בעבר.

דוחות מילוי חוסרים (backfill) שמכילים נתונים מ-1 ביוני 2018 או לאחר מכן, לא יכללו הפניות למשאבים של YouTube שנמחקו לפחות 30 ימים לפני תאריך יצירת הדוח.

נתונים היסטוריים

כשאתם מתזמנים משימת דיווח חדשה, המערכת של YouTube יוצרת דוחות היסטוריים שמסקרים תקופה שקדמה למועד יצירת המשרה. לכן, במסמכי התיעוד הזה, נתונים היסטוריים הם דוח שמכיל נתונים מתקופה שקדמה למשימת הדיווח.

חשוב:שינוי שנבצע בקרוב במדיניות ישפיע על משך הזמן שבו הנתונים ההיסטוריים של הדוח נוצרים. נכון לעכשיו, השינוי מתוכנן להיכנס לתוקף ביולי 2018, והוא חל בכל העולם על כל משימות הדיווח והדיווח.

  • לפני השינוי במדיניות, כשתתזמנו משימת דיווח חדשה, המערכת של YouTube תיצור דוחות לגבי התקופה של 180 הימים שלפני מועד היצירה של המשימה.
  • אחרי השינוי במדיניות, כשתתזמנו משימת דיווח חדשה, המערכת של YouTube תפיק דוחות מאותו יום ואילך, והם יכסו את התקופה של 30 הימים שלפני מועד היצירה של המשימה.

דוחות היסטוריים מפורסמים ברגע שהם זמינים. בדרך כלל, כל הנתונים ההיסטוריים מתפרסמים על משרה תוך כמה ימים. כפי שמוסבר בקטע מאפייני דוח, אחרי שינוי מדיניות שייכנס לתוקף ביולי 2018, דוחות שמכילים נתונים היסטוריים יהיו זמינים למשך 30 יום מהמועד שבו הופקו. דוחות שמכילים נתונים לא היסטוריים יהיו זמינים למשך 60 יום לאחר שינוי המדיניות.

אנונימיזציה של נתונים

כדי לשמור על האנונימיות של צופים ב-YouTube, הערכים של מאפיינים מסוימים מוחזרים רק אם מדד באותה שורה עומד בסף מסוים.

לדוגמה, בדוח 'מקורות תנועה של מודעות וידאו' בערוצים, כל שורה מכילה כמה מאפיינים, כולל traffic_source_type ו-traffic_source_detail. כל שורה מכילה גם מדדים שונים, כולל תצוגות מפורטות. בשורות שמתארות תנועה שמגיעה מחיפוש ב-YouTube, המאפיין traffic_source_detail מזהה את מונח החיפוש שהוביל לתנועה.

בדוגמה הזו חלים הכללים הבאים:

  • הדוח 'מקורות תנועה' מזהה את מונח השאילתה (traffic_source_detail) רק אם הוא הוביל לפחות למספר מסוים של צפיות בסרטון מסוים ביום מסוים. במקרה הזה, צפיות הוא המדד, video_id הוא המאפיין המצטבר ו-traffic_source_detail הוא המאפיין האנונימי.

  • הדוח כולל שורה נוספת שמרכזת את המדדים של כל הערכים של traffic_source_detail שלא עומדים בסף מספר הצפיות. השורה הזו מדווחת על המספר הכולל של הצפיות שמשויכות למונחי השאילתה האלה, אבל לא מזהה את המונחים עצמם.

הטבלאות הבאות ממחישות את הכללים האלו. הטבלה הראשונה מכילה קבוצה היפותטית של נתונים גולמיים שישמשו את YouTube ליצירת דוח של מקור תנועה, והטבלה השנייה מכילה את הדוח עצמו. בדוגמה הזו, הסף לספירת הצפיות הוא 10, כלומר הדוח מזהה מונח חיפוש רק אם הוא הוביל לפחות ל-10 צפיות בסרטון מסוים ביום מסוים. (סכומי הסף בפועל עשויים להשתנות).

נתונים גולמיים של תנועת חיפוש ב-YouTube לסרטון

נניח שהנתונים הבאים מתארים את תנועת החיפוש ב-YouTube לסרטון מסוים ביום מסוים.

מונח חיפוש צפיות אומדן של מספר הדקות שנצפו
גנגנם סטייל 100 200
פסי 15 25
פסי גנגנם 9 15
Oppa Ganggnam 5 8
ריקוד על רכיבה על סוסים 2 5

דוח לדוגמה של מקור תנועה

בטבלה הבאה מוצג חלק מהדוח 'מקורות תנועה' שמערכת YouTube תיצור עבור הנתונים הגולמיים בקטע הקודם. (הדוח עצמו יכיל עוד מאפיינים ומדדים). בדוגמה הזו, הדוח מזהה מונחי חיפוש רק אם הם הובילו ל-10 צפיות לפחות. סכומי הסף בפועל עשויים להשתנות.

בשורה השלישית של הדוח, ערך המאפיין trafficSourceDetail הוא NULL. המדדים views ו-estimatedMinutesWatched כוללים את השילוב של מספר הצפיות והדקות שנצפו עבור שלושת מונחי החיפוש שהניבו פחות מ-10 צפיות.

trafficSourceDetail צפיות estimatedMinutesWatched
גנגנם סטייל 100 200
פסי 15 25
NULL 16 28

המאפיינים כפופים לאנונימיזציה

בטבלה הבאה מפורטים ערכי מאפיינים שעברו אנונימיזציה אם ערכי המדדים המשויכים לא עומדים בסף מסוים. בכל אחד מהמקרים, הערך של המדד נצבר מעל מאפיין אחר. לדוגמה, אם המדד הוא צפיות והמאפיין המצטבר הוא video_id, ערך המאפיין עובר אנונימיזציה, אלא אם הסרטון נצפה מספר מסוים של פעמים.

המדד מאפיינים מצטברים מאפיין אנונימי ערך שעבר אנונימיזציה
subscribers_gained channel_id country_code ZZ
subscribers_gained channel_id province_code US-ZZ
subscribers_lost channel_id country_code ZZ
subscribers_lost channel_id province_code US-ZZ
תגובות video_id country_code ZZ
תגובות video_id province_code US-ZZ
לייקים video_id country_code ZZ
לייקים video_id province_code US-ZZ
דיסלייקים video_id country_code ZZ
דיסלייקים video_id province_code US-ZZ
צפיות video_id age_group NULL
צפיות video_id מגדר NULL
צפיות video_id ו-traffic_source_detail traffic_source_detail NULL
מספר המנויים בערוץ channel_id subscribed_status NULL

דוגמאות קוד

דוגמאות הקוד הבאות מדגימות איך להשתמש ב-API כדי ליצור משימת דיווח ואז לאחזר דוח לגבי המשימה הזו. שתי דוגמאות קוד ניתנות לכל שפה:

  1. דוגמת הקוד הראשונה מראה איך לאחזר רשימה של סוגי דוחות זמינים ולאחר מכן ליצור משימת דיווח חדשה.

  2. דוגמת הקוד השנייה מראה כיצד לאחזר דוח עבור משימה מסוימת. אפשר להתחיל לאחזר דוחות תוך 48 שעות ממועד יצירת המשימה.

הערה: יכול להיות שדוגמאות הקוד הבאות לא מייצגות את כל שפות התכנות הנתמכות. כדי לקבל רשימה של שפות נתמכות, אפשר לעיין במסמכי התיעוד של ספריות הלקוח.

Java

הדוגמאות הבאות משתמשות בספריית הלקוח של Java:

דוגמה 1: יצירה של משימת דיווח

דוגמת הקוד הבאה מפעילה את השיטה reportTypes.list כדי לאחזר רשימה של סוגי דוחות זמינים. לאחר מכן המערכת מפעילה את השיטה jobs.create כדי ליצור משימת דיווח חדשה.

/*
 * Copyright (c) 2015 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.api.services.samples.youtube.cmdline.reporting;

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.services.samples.youtube.cmdline.Auth;
import com.google.api.services.youtubereporting.YouTubeReporting;
import com.google.api.services.youtubereporting.model.Job;
import com.google.api.services.youtubereporting.model.ListReportTypesResponse;
import com.google.api.services.youtubereporting.model.ReportType;
import com.google.common.collect.Lists;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;

/**
 * This sample creates a reporting job by:
 *
 * 1. Listing the available report types using the "reportTypes.list" method.
 * 2. Creating a reporting job using the "jobs.create" method.
 *
 * @author Ibrahim Ulukaya
 */
public class CreateReportingJob {

    /**
     * Define a global instance of a YouTube Reporting object, which will be used to make
     * YouTube Reporting API requests.
     */
    private static YouTubeReporting youtubeReporting;


    /**
     * Create a reporting job.
     *
     * @param args command line args (not used).
     */
    public static void main(String[] args) {

        /*
         * This OAuth 2.0 access scope allows for read access to the YouTube Analytics monetary reports for
         * authenticated user's account. Any request that retrieves earnings or ad performance metrics must
         * use this scope.
         */
        List<String> scopes = Lists.newArrayList("https://www.googleapis.com/auth/yt-analytics-monetary.readonly");

        try {
            // Authorize the request.
            Credential credential = Auth.authorize(scopes, "createreportingjob");

            // This object is used to make YouTube Reporting API requests.
            youtubeReporting = new YouTubeReporting.Builder(Auth.HTTP_TRANSPORT, Auth.JSON_FACTORY, credential)
                    .setApplicationName("youtube-cmdline-createreportingjob-sample").build();

            // Prompt the user to specify the name of the job to be created.
            String name = getNameFromUser();

            if (listReportTypes()) {
              createReportingJob(getReportTypeIdFromUser(), name);
            }
        } catch (GoogleJsonResponseException e) {
            System.err.println("GoogleJsonResponseException code: " + e.getDetails().getCode()
                    + " : " + e.getDetails().getMessage());
            e.printStackTrace();

        } catch (IOException e) {
            System.err.println("IOException: " + e.getMessage());
            e.printStackTrace();
        } catch (Throwable t) {
            System.err.println("Throwable: " + t.getMessage());
            t.printStackTrace();
        }
    }

    /**
     * Lists report types. (reportTypes.listReportTypes)
     * @return true if at least one report type exists
     * @throws IOException
     */
    private static boolean listReportTypes() throws IOException {
        // Call the YouTube Reporting API's reportTypes.list method to retrieve report types.
        ListReportTypesResponse reportTypesListResponse = youtubeReporting.reportTypes().list()
            .execute();
        List<ReportType> reportTypeList = reportTypesListResponse.getReportTypes();

        if (reportTypeList == null || reportTypeList.isEmpty()) {
          System.out.println("No report types found.");
          return false;
        } else {
            // Print information from the API response.
            System.out.println("\n================== Report Types ==================\n");
            for (ReportType reportType : reportTypeList) {
                System.out.println("  - Id: " + reportType.getId());
                System.out.println("  - Name: " + reportType.getName());
                System.out.println("\n-------------------------------------------------------------\n");
           }
        }
        return true;
    }

    /**
     * Creates a reporting job. (jobs.create)
     *
     * @param reportTypeId Id of the job's report type.
     * @param name name of the job.
     * @throws IOException
     */
    private static void createReportingJob(String reportTypeId, String name)
        throws IOException {
        // Create a reporting job with a name and a report type id.
        Job job = new Job();
        job.setReportTypeId(reportTypeId);
        job.setName(name);

        // Call the YouTube Reporting API's jobs.create method to create a job.
        Job createdJob = youtubeReporting.jobs().create(job).execute();

        // Print information from the API response.
        System.out.println("\n================== Created reporting job ==================\n");
        System.out.println("  - ID: " + createdJob.getId());
        System.out.println("  - Name: " + createdJob.getName());
        System.out.println("  - Report Type Id: " + createdJob.getReportTypeId());
        System.out.println("  - Create Time: " + createdJob.getCreateTime());
        System.out.println("\n-------------------------------------------------------------\n");
    }

    /*
     * Prompt the user to enter a name for the job. Then return the name.
     */
    private static String getNameFromUser() throws IOException {

        String name = "";

        System.out.print("Please enter the name for the job [javaTestJob]: ");
        BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
        name = bReader.readLine();

        if (name.length() < 1) {
            // If nothing is entered, defaults to "javaTestJob".
          name = "javaTestJob";
        }

        System.out.println("You chose " + name + " as the name for the job.");
        return name;
    }

    /*
     * Prompt the user to enter a report type id for the job. Then return the id.
     */
    private static String getReportTypeIdFromUser() throws IOException {

        String id = "";

        System.out.print("Please enter the reportTypeId for the job: ");
        BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
        id = bReader.readLine();

        System.out.println("You chose " + id + " as the report type Id for the job.");
        return id;
    }
}

דוגמה 2: אחזור דוח

דוגמת הקוד מפעילה את השיטה jobs.list כדי לאחזר רשימה של משימות דיווח. לאחר מכן, היא מפעילה את השיטה reports.list עם הפרמטר jobId עם מזהה משימה ספציפי, כדי לאחזר דוחות שנוצרו על ידי המשימה הזו. בסוף, הדוגמה מדפיסה את כתובת ה-URL להורדה של כל דוח.

/*
 * Copyright (c) 2015 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.api.services.samples.youtube.cmdline.reporting;

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.GenericUrl;
import com.google.api.services.samples.youtube.cmdline.Auth;
import com.google.api.services.youtubereporting.YouTubeReporting;
import com.google.api.services.youtubereporting.YouTubeReporting.Media.Download;
import com.google.api.services.youtubereporting.model.Job;
import com.google.api.services.youtubereporting.model.ListJobsResponse;
import com.google.api.services.youtubereporting.model.ListReportsResponse;
import com.google.api.services.youtubereporting.model.Report;

import com.google.common.collect.Lists;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;

import javax.print.attribute.standard.Media;

/**
 * This sample retrieves reports created by a specific job by:
 *
 * 1. Listing the jobs using the "jobs.list" method.
 * 2. Retrieving reports using the "reports.list" method.
 *
 * @author Ibrahim Ulukaya
 */
public class RetrieveReports {

    /**
     * Define a global instance of a YouTube Reporting object, which will be used to make
     * YouTube Reporting API requests.
     */
    private static YouTubeReporting youtubeReporting;


    /**
     * Retrieve reports.
     *
     * @param args command line args (not used).
     */
    public static void main(String[] args) {

        /*
         * This OAuth 2.0 access scope allows for read access to the YouTube Analytics monetary reports for
         * authenticated user's account. Any request that retrieves earnings or ad performance metrics must
         * use this scope.
         */
        List<String> scopes = Lists.newArrayList("https://www.googleapis.com/auth/yt-analytics-monetary.readonly");

        try {
            // Authorize the request.
            Credential credential = Auth.authorize(scopes, "retrievereports");

            // This object is used to make YouTube Reporting API requests.
            youtubeReporting = new YouTubeReporting.Builder(Auth.HTTP_TRANSPORT, Auth.JSON_FACTORY, credential)
                    .setApplicationName("youtube-cmdline-retrievereports-sample").build();

            if (listReportingJobs()) {
              if(retrieveReports(getJobIdFromUser())) {
                downloadReport(getReportUrlFromUser());
              }
            }
        } catch (GoogleJsonResponseException e) {
            System.err.println("GoogleJsonResponseException code: " + e.getDetails().getCode()
                    + " : " + e.getDetails().getMessage());
            e.printStackTrace();

        } catch (IOException e) {
            System.err.println("IOException: " + e.getMessage());
            e.printStackTrace();
        } catch (Throwable t) {
            System.err.println("Throwable: " + t.getMessage());
            t.printStackTrace();
        }
    }

    /**
     * Lists reporting jobs. (jobs.listJobs)
     * @return true if at least one reporting job exists
     * @throws IOException
     */
    private static boolean listReportingJobs() throws IOException {
        // Call the YouTube Reporting API's jobs.list method to retrieve reporting jobs.
        ListJobsResponse jobsListResponse = youtubeReporting.jobs().list().execute();
        List<Job> jobsList = jobsListResponse.getJobs();

        if (jobsList == null || jobsList.isEmpty()) {
          System.out.println("No jobs found.");
          return false;
        } else {
            // Print information from the API response.
            System.out.println("\n================== Reporting Jobs ==================\n");
            for (Job job : jobsList) {
                System.out.println("  - Id: " + job.getId());
                System.out.println("  - Name: " + job.getName());
                System.out.println("  - Report Type Id: " + job.getReportTypeId());
                System.out.println("\n-------------------------------------------------------------\n");
            }
        }
        return true;
    }

    /**
     * Lists reports created by a specific job. (reports.listJobsReports)
     *
     * @param jobId The ID of the job.
     * @throws IOException
     */
    private static boolean retrieveReports(String jobId)
        throws IOException {
        // Call the YouTube Reporting API's reports.list method
        // to retrieve reports created by a job.
        ListReportsResponse reportsListResponse = youtubeReporting.jobs().reports().list(jobId).execute();
        List<Report> reportslist = reportsListResponse.getReports();

        if (reportslist == null || reportslist.isEmpty()) {
            System.out.println("No reports found.");
            return false;
        } else {
            // Print information from the API response.
            System.out.println("\n============= Reports for the job " + jobId + " =============\n");
            for (Report report : reportslist) {
                System.out.println("  - Id: " + report.getId());
                System.out.println("  - From: " + report.getStartTime());
                System.out.println("  - To: " + report.getEndTime());
                System.out.println("  - Download Url: " + report.getDownloadUrl());
                System.out.println("\n-------------------------------------------------------------\n");
            }
        }
        return true;
    }

    /**
     * Download the report specified by the URL. (media.download)
     *
     * @param reportUrl The URL of the report to be downloaded.
     * @throws IOException
     */
    private static boolean downloadReport(String reportUrl)
        throws IOException {
        // Call the YouTube Reporting API's media.download method to download a report.
        Download request = youtubeReporting.media().download("");
        FileOutputStream fop = new FileOutputStream(new File("report"));
        request.getMediaHttpDownloader().download(new GenericUrl(reportUrl), fop);
        return true;
    }

    /*
     * Prompt the user to enter a job id for report retrieval. Then return the id.
     */
    private static String getJobIdFromUser() throws IOException {

        String id = "";

        System.out.print("Please enter the job id for the report retrieval: ");
        BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
        id = bReader.readLine();

        System.out.println("You chose " + id + " as the job Id for the report retrieval.");
        return id;
    }

    /*
     * Prompt the user to enter a URL for report download. Then return the URL.
     */
    private static String getReportUrlFromUser() throws IOException {

        String url = "";

        System.out.print("Please enter the report URL to download: ");
        BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
        url = bReader.readLine();

        System.out.println("You chose " + url + " as the URL to download.");
        return url;
    }}

PHP

בדוגמאות הבאות נעשה שימוש בספריית הלקוח של PHP.

דוגמה 1: יצירה של משימת דיווח

דוגמת הקוד הבאה מפעילה את השיטה reportTypes.list כדי לאחזר רשימה של סוגי דוחות זמינים. לאחר מכן המערכת מפעילה את השיטה jobs.create כדי ליצור משימת דיווח חדשה.

<?php

/**
 * This sample creates a reporting job by:
 *
 * 1. Listing the available report types using the "reportTypes.list" method.
 * 2. Creating a reporting job using the "jobs.create" method.
 *
 * @author Ibrahim Ulukaya
 */

/**
 * Library Requirements
 *
 * 1. Install composer (https://getcomposer.org)
 * 2. On the command line, change to this directory (api-samples/php)
 * 3. Require the google/apiclient library
 *    $ composer require google/apiclient:~2.0
 */
if (!file_exists(__DIR__ . '/vendor/autoload.php')) {
  throw new \Exception('please run "composer require google/apiclient:~2.0" in "' . __DIR__ .'"');
}

require_once __DIR__ . '/vendor/autoload.php';
session_start();

/*
 * You can acquire an OAuth 2.0 client ID and client secret from the
 * {{ Google Cloud Console }} <{{ https://cloud.google.com/console }}>
 * For more information about using OAuth 2.0 to access Google APIs, please see:
 * <https://developers.google.com/youtube/v3/guides/authentication>
 * Please ensure that you have enabled the YouTube Data API for your project.
 */
$OAUTH2_CLIENT_ID = 'REPLACE_ME';
$OAUTH2_CLIENT_SECRET = 'REPLACE_ME';

$client = new Google_Client();
$client->setClientId($OAUTH2_CLIENT_ID);
$client->setClientSecret($OAUTH2_CLIENT_SECRET);

/*
 * This OAuth 2.0 access scope allows for read access to the YouTube Analytics monetary reports for
 * authenticated user's account. Any request that retrieves earnings or ad performance metrics must
 * use this scope.
 */
$client->setScopes('https://www.googleapis.com/auth/yt-analytics-monetary.readonly');
$redirect = filter_var('http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'],
    FILTER_SANITIZE_URL);
$client->setRedirectUri($redirect);

// YouTube Reporting object used to make YouTube Reporting API requests.
$youtubeReporting = new Google_Service_YouTubeReporting($client);

// Check if an auth token exists for the required scopes
$tokenSessionKey = 'token-' . $client->prepareScopes();
if (isset($_GET['code'])) {
  if (strval($_SESSION['state']) !== strval($_GET['state'])) {
    die('The session state did not match.');
  }

  $client->authenticate($_GET['code']);
  $_SESSION[$tokenSessionKey] = $client->getAccessToken();
  header('Location: ' . $redirect);
}

if (isset($_SESSION[$tokenSessionKey])) {
  $client->setAccessToken($_SESSION[$tokenSessionKey]);
}

// Check to ensure that the access token was successfully acquired.
if ($client->getAccessToken()) {
  // This code executes if the user enters a name in the form
  // and submits the form. Otherwise, the page displays the form above.
  try {
    if (empty(listReportTypes($youtubeReporting, $htmlBody))) {
      $htmlBody .= sprintf('<p>No report types found.</p>');
    } else if ($_GET['reportTypeId']){
      createReportingJob($youtubeReporting, $_GET['reportTypeId'], $_GET['jobName'], $htmlBody);
    }
  } catch (Google_Service_Exception $e) {
    $htmlBody = sprintf('<p>A service error occurred: <code>%s</code></p>',
        htmlspecialchars($e->getMessage()));
  } catch (Google_Exception $e) {
    $htmlBody = sprintf('<p>An client error occurred: <code>%s</code></p>',
        htmlspecialchars($e->getMessage()));
  }
  $_SESSION[$tokenSessionKey] = $client->getAccessToken();
} elseif ($OAUTH2_CLIENT_ID == 'REPLACE_ME') {
  $htmlBody = <<<END
  <h3>Client Credentials Required</h3>
  <p>
    You need to set <code>\$OAUTH2_CLIENT_ID</code> and
    <code>\$OAUTH2_CLIENT_ID</code> before proceeding.
  <p>
END;
} else {
  // If the user hasn't authorized the app, initiate the OAuth flow
  $state = mt_rand();
  $client->setState($state);
  $_SESSION['state'] = $state;

  $authUrl = $client->createAuthUrl();
  $htmlBody = <<<END
  <h3>Authorization Required</h3>
  <p>You need to <a href="$authUrl">authorize access</a> before proceeding.<p>
END;
}


/**
 * Creates a reporting job. (jobs.create)
 *
 * @param Google_Service_YouTubereporting $youtubeReporting YouTube Reporting service object.
 * @param string $reportTypeId Id of the job's report type.
 * @param string $name name of the job.
 * @param $htmlBody - html body.
 */
function createReportingJob(Google_Service_YouTubeReporting $youtubeReporting, $reportTypeId,
    $name, &$htmlBody) {
  # Create a reporting job with a name and a report type id.
  $reportingJob = new Google_Service_YouTubeReporting_Job();
  $reportingJob->setReportTypeId($reportTypeId);
  $reportingJob->setName($name);

  // Call the YouTube Reporting API's jobs.create method to create a job.
  $jobCreateResponse = $youtubeReporting->jobs->create($reportingJob);

  $htmlBody .= "<h2>Created reporting job</h2><ul>";
  $htmlBody .= sprintf('<li>"%s" for reporting type "%s" at "%s"</li>',
      $jobCreateResponse['name'], $jobCreateResponse['reportTypeId'], $jobCreateResponse['createTime']);
  $htmlBody .= '</ul>';
}


/**
 * Returns a list of report types. (reportTypes.listReportTypes)
 *
 * @param Google_Service_YouTubereporting $youtubeReporting YouTube Reporting service object.
 * @param $htmlBody - html body.
 */
function listReportTypes(Google_Service_YouTubeReporting $youtubeReporting, &$htmlBody) {
  // Call the YouTube Reporting API's reportTypes.list method to retrieve report types.
  $reportTypes = $youtubeReporting->reportTypes->listReportTypes();

  $htmlBody .= "<h3>Report Types</h3><ul>";
  foreach ($reportTypes as $reportType) {
    $htmlBody .= sprintf('<li>id: "%s", name: "%s"</li>', $reportType['id'], $reportType['name']);
  }
  $htmlBody .= '</ul>';

  return $reportTypes;
}
?>

<!doctype html>
<html>
<head>
<title>Create a reporting job</title>
</head>
<body>
  <form method="GET">
    <div>
      Job Name: <input type="text" id="jobName" name="jobName" placeholder="Enter Job Name">
    </div>
    <br>
    <div>
      Report Type Id: <input type="text" id="reportTypeId" name="reportTypeId" placeholder="Enter Report Type Id">
    </div>
    <br>
    <input type="submit" value="Create!">
  </form>
  <?=$htmlBody?>
</body>
</html>

דוגמה 2: אחזור דוח

דוגמת הקוד מפעילה את השיטה jobs.list כדי לאחזר רשימה של משימות דיווח. לאחר מכן, היא מפעילה את השיטה reports.list עם הפרמטר jobId עם מזהה משימה ספציפי, כדי לאחזר דוחות שנוצרו על ידי המשימה הזו. בסוף, הדוגמה מדפיסה את כתובת ה-URL להורדה של כל דוח.

<?php

/**
 * This sample supports the following use cases:
 *
 * 1. Retrieve reporting jobs by content owner:
 *    Ex: php retrieve_reports.php  --contentOwner=="CONTENT_OWNER_ID"
 *    Ex: php retrieve_reports.php  --contentOwner=="CONTENT_OWNER_ID" --includeSystemManaged==True
 * 2. Retrieving list of downloadable reports for a particular job:
 *    Ex: php retrieve_reports.php  --contentOwner=="CONTENT_OWNER_ID" --jobId="JOB_ID"
 * 3. Download a report:
 *    Ex: php retrieve_reports.php  --contentOwner=="CONTENT_OWNER_ID" --downloadUrl="DOWNLOAD_URL" --outputFile="report.txt"
 */

/**
 * Library Requirements
 *
 * 1. Install composer (https://getcomposer.org)
 * 2. On the command line, change to this directory (api-samples/php)
 * 3. Require the google/apiclient library
 *    $ composer require google/apiclient:~2.0
 */
if (!file_exists(__DIR__ . '/vendor/autoload.php')) {
  throw new \Exception('please run "composer require google/apiclient:~2.2.0" in "' . __DIR__ .'"');
}

require_once __DIR__ . '/vendor/autoload.php';
session_start();


define('CREDENTIALS_PATH', '~/.credentials/youtube-php.json');

$longOptions = array(
  'contentOwner::',
  'downloadUrl::',
  'includeSystemManaged::',
  'jobId::',
  'outputFile::',
);

$options = getopt('', $longOptions);

$CONTENT_OWNER_ID = ($options['contentOwner'] ? $options['contentOwner'] : '');
$DOWNLOAD_URL = (array_key_exists('downloadUrl', $options) ?
                 $options['downloadUrl'] : '');
$INCLUDE_SYSTEM_MANAGED = (array_key_exists('includeSystemManaged', $options) ?
                           $options['includeSystemManaged'] : '');
$JOB_ID = (array_key_exists('jobId', $options) ? $options['jobId'] : '');
$OUTPUT_FILE = (array_key_exists('outputFile', $options) ?
                $options['outputFile'] : '');

/*
 * You can obtain an OAuth 2.0 client ID and client secret from the
 * {{ Google Cloud Console }} <{{ https://cloud.google.com/console }}>
 * For more information about using OAuth 2.0 to access Google APIs, please see:
 * <https://developers.google.com/youtube/v3/guides/authentication>
 * Please ensure that you have enabled the YouTube Data API for your project.
 */
function getClient() {
  $client = new Google_Client();
  $client->setAuthConfigFile('client_secrets_php.json');
  $client->addScope(
      'https://www.googleapis.com/auth/yt-analytics-monetary.readonly');
  $client->setRedirectUri('urn:ietf:wg:oauth:2.0:oob');
  $client->setAccessType('offline');

  // Load previously authorized credentials from a file.
  $credentialsPath = expandHomeDirectory(CREDENTIALS_PATH);
  if (file_exists($credentialsPath)) {
    $accessToken = json_decode(file_get_contents($credentialsPath), true);
  } else {
    // Request authorization from the user.
    $authUrl = $client->createAuthUrl();
    printf('Open the following link in your browser:\n%s\n', $authUrl);
    print 'Enter verification code: ';
    $authCode = trim(fgets(STDIN));

    // Exchange authorization code for an access token.
    $accessToken = $client->authenticate($authCode);
    $refreshToken = $client->getRefreshToken();

    // Store the credentials to disk.
    if(!file_exists(dirname($credentialsPath))) {
      mkdir(dirname($credentialsPath), 0700, true);
    }
    file_put_contents($credentialsPath, json_encode($accessToken));
    printf('Credentials saved to %s\n', $credentialsPath);

    //fclose($fp);
  }
  $client->setAccessToken($accessToken);

  // Refresh the token if it's expired.
  if ($client->isAccessTokenExpired()) {
    $client->fetchAccessTokenWithRefreshToken($client->getRefreshToken());
    file_put_contents($credentialsPath, json_encode($client->getAccessToken()));
  }

  return $client;
}

/**
 * Expands the home directory alias '~' to the full path.
 * @param string $path the path to expand.
 * @return string the expanded path.
 */
function expandHomeDirectory($path) {
  $homeDirectory = getenv('HOME');
  if (empty($homeDirectory)) {
    $homeDirectory = getenv('HOMEDRIVE') . getenv('HOMEPATH');
  }
  return str_replace('~', realpath($homeDirectory), $path);
}

/**
 * Returns a list of reporting jobs. (jobs.listJobs)
 *
 * @param Google_Service_YouTubereporting $youtubeReporting YouTube Reporting service object.
 * @param string $onBehalfOfContentOwner A content owner ID.
 */
function listReportingJobs(Google_Service_YouTubeReporting $youtubeReporting,
    $onBehalfOfContentOwner = '', $includeSystemManaged = False) {
  $reportingJobs = $youtubeReporting->jobs->listJobs(
      array('onBehalfOfContentOwner' => $onBehalfOfContentOwner,
            'includeSystemManaged' => $includeSystemManaged));
  print ('REPORTING JOBS' . PHP_EOL . '**************' . PHP_EOL);
  foreach ($reportingJobs as $job) {
    print($job['reportTypeId'] . ':' . $job['id'] . PHP_EOL);
  }
  print(PHP_EOL);
}

/**
 * Lists reports created by a specific job. (reports.listJobsReports)
 *
 * @param Google_Service_YouTubereporting $youtubeReporting YouTube Reporting service object.
 * @param string $jobId The ID of the job.
 * @param string $onBehalfOfContentOwner A content owner ID.
 */
function listReportsForJob(Google_Service_YouTubeReporting $youtubeReporting,
    $jobId, $onBehalfOfContentOwner = '') {
  $reports = $youtubeReporting->jobs_reports->listJobsReports($jobId,
      array('onBehalfOfContentOwner' => $onBehalfOfContentOwner));
  print ('DOWNLOADABLE REPORTS' . PHP_EOL . '********************' . PHP_EOL);
  foreach ($reports['reports'] as $report) {
    print('Created: ' . date('d M Y', strtotime($report['createTime'])) .
          ' (' . date('d M Y', strtotime($report['startTime'])) .
          ' to ' . date('d M Y', strtotime($report['endTime'])) . ')' .
          PHP_EOL .  '    ' . $report['downloadUrl'] . PHP_EOL . PHP_EOL);
  }
}

/**
 * Download the report specified by the URL. (media.download)
 *
 * @param Google_Service_YouTubereporting $youtubeReporting YouTube Reporting service object.
 * @param string $reportUrl The URL of the report to be downloaded.
 * @param string $outputFile The file to write the report to locally.
 * @param $htmlBody - html body.
 */
function downloadReport(Google_Service_YouTubeReporting $youtubeReporting,
    $reportUrl, $outputFile) {
  $client = $youtubeReporting->getClient();
  // Setting the defer flag to true tells the client to return a request that
  // can be called with ->execute(); instead of making the API call immediately.
  $client->setDefer(true);

  // Call YouTube Reporting API's media.download method to download a report.
  $request = $youtubeReporting->media->download('', array('alt' => 'media'));
  $request = $request->withUri(new \GuzzleHttp\Psr7\Uri($reportUrl));
  $responseBody = '';
  try {
    $response = $client->execute($request);
    $responseBody = $response->getBody();
  } catch (Google_Service_Exception $e) {
    $responseBody = $e->getTrace()[0]['args'][0]->getResponseBody();
  }
  file_put_contents($outputFile, $responseBody);
  $client->setDefer(false);
}

// Define an object that will be used to make all API requests.
$client = getClient();
// YouTube Reporting object used to make YouTube Reporting API requests.
$youtubeReporting = new Google_Service_YouTubeReporting($client);

if ($CONTENT_OWNER_ID) {
  if (!$DOWNLOAD_URL && !$JOB_ID) {
    listReportingJobs($youtubeReporting, $CONTENT_OWNER_ID,
                      $INCLUDE_SYSTEM_MANAGED);
  } else if ($JOB_ID) {
    listReportsForJob($youtubeReporting, $JOB_ID, $CONTENT_OWNER_ID);
  } else if ($DOWNLOAD_URL && $OUTPUT_FILE) {
    downloadReport($youtubeReporting, $DOWNLOAD_URL, $OUTPUT_FILE);
  }
}

?>

Python

בדוגמאות הבאות נעשה שימוש בספריית הלקוח של Python.

דוגמה 1: יצירה של משימת דיווח

דוגמת הקוד הבאה מפעילה את השיטה reportTypes.list כדי לאחזר רשימה של סוגי דוחות זמינים. לאחר מכן המערכת מפעילה את השיטה jobs.create כדי ליצור משימת דיווח חדשה.

#!/usr/bin/python

# Create a reporting job for the authenticated user's channel or
# for a content owner that the user's account is linked to.
# Usage example:
# python create_reporting_job.py --name='<name>'
# python create_reporting_job.py --content-owner='<CONTENT OWNER ID>'
# python create_reporting_job.py --content-owner='<CONTENT_OWNER_ID>' --report-type='<REPORT_TYPE_ID>' --name='<REPORT_NAME>'

import argparse
import os

import google.oauth2.credentials
import google_auth_oauthlib.flow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from google_auth_oauthlib.flow import InstalledAppFlow


# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains

# the OAuth 2.0 information for this application, including its client_id and
# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
# the {{ Google Cloud Console }} at
# {{ https://cloud.google.com/console }}.
# Please ensure that you have enabled the YouTube Data API for your project.
# For more information about using OAuth2 to access the YouTube Data API, see:
#   https://developers.google.com/youtube/v3/guides/authentication
# For more information about the client_secrets.json file format, see:
#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
CLIENT_SECRETS_FILE = 'client_secret.json'

# This OAuth 2.0 access scope allows for read access to the YouTube Analytics monetary reports for
# authenticated user's account. Any request that retrieves earnings or ad performance metrics must
# use this scope.
SCOPES = ['https://www.googleapis.com/auth/yt-analytics-monetary.readonly']
API_SERVICE_NAME = 'youtubereporting'
API_VERSION = 'v1'

# Authorize the request and store authorization credentials.
def get_authenticated_service():
  flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
  credentials = flow.run_console()
  return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)

# Remove keyword arguments that are not set.
def remove_empty_kwargs(**kwargs):
  good_kwargs = {}
  if kwargs is not None:
    for key, value in kwargs.iteritems():
      if value:
        good_kwargs[key] = value
  return good_kwargs

# Call the YouTube Reporting API's reportTypes.list method to retrieve report types.
def list_report_types(youtube_reporting, **kwargs):
  # Provide keyword arguments that have values as request parameters.
  kwargs = remove_empty_kwargs(**kwargs)
  results = youtube_reporting.reportTypes().list(**kwargs).execute()
  reportTypes = results['reportTypes']

  if 'reportTypes' in results and results['reportTypes']:
    reportTypes = results['reportTypes']
    for reportType in reportTypes:
      print 'Report type id: %s\n name: %s\n' % (reportType['id'], reportType['name'])
  else:
    print 'No report types found'
    return False

  return True


# Call the YouTube Reporting API's jobs.create method to create a job.
def create_reporting_job(youtube_reporting, report_type_id, **kwargs):
  # Provide keyword arguments that have values as request parameters.
  kwargs = remove_empty_kwargs(**kwargs)

  reporting_job = youtube_reporting.jobs().create(
    body=dict(
      reportTypeId=args.report_type,
      name=args.name
    ),
    **kwargs
  ).execute()

  print ('Reporting job "%s" created for reporting type "%s" at "%s"'
         % (reporting_job['name'], reporting_job['reportTypeId'],
             reporting_job['createTime']))


# Prompt the user to enter a report type id for the job. Then return the id.
def get_report_type_id_from_user():
  report_type_id = raw_input('Please enter the reportTypeId for the job: ')
  print ('You chose "%s" as the report type Id for the job.' % report_type_id)
  return report_type_id

# Prompt the user to set a job name
def prompt_user_to_set_job_name():
  job_name = raw_input('Please set a name for the job: ')
  print ('Great! "%s" is a memorable name for this job.' % job_name)
  return job_name


if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  # The 'name' option specifies the name that will be used for the reporting job.
  parser.add_argument('--content-owner', default='',
      help='ID of content owner for which you are retrieving jobs and reports.')
  parser.add_argument('--include-system-managed', default=False,
      help='Whether the API response should include system-managed reports')
  parser.add_argument('--name', default='',
    help='Name for the reporting job. The script prompts you to set a name ' +
         'for the job if you do not provide one using this argument.')
  parser.add_argument('--report-type', default=None,
    help='The type of report for which you are creating a job.')
  args = parser.parse_args()

  youtube_reporting = get_authenticated_service()

  try:
    # Prompt user to select report type if they didn't set one on command line.
    if not args.report_type:
      if list_report_types(youtube_reporting,
                           onBehalfOfContentOwner=args.content_owner,
                           includeSystemManaged=args.include_system_managed):
        args.report_type = get_report_type_id_from_user()
    # Prompt user to set job name if not set on command line.
    if not args.name:
      args.name = prompt_user_to_set_job_name()
    # Create the job.
    if args.report_type:
      create_reporting_job(youtube_reporting,
                           args,
                           onBehalfOfContentOwner=args.content_owner)
  except HttpError, e:
    print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)

דוגמה 2: אחזור דוח

דוגמת הקוד מפעילה את השיטה jobs.list כדי לאחזר רשימה של משימות דיווח. לאחר מכן, היא מפעילה את השיטה reports.list עם הפרמטר jobId עם מזהה משימה ספציפי, כדי לאחזר דוחות שנוצרו על ידי המשימה הזו. בסוף, הדוגמה מדפיסה את כתובת ה-URL להורדה של כל דוח.

#!/usr/bin/python

###
#
# This script retrieves YouTube Reporting API reports. Use cases:
# 1. If you specify a report URL, the script downloads that report.
# 2. Otherwise, if you specify a job ID, the script retrieves a list of
#    available reports for that job and prompts you to select a report.
#    Then it retrieves that report as in case 1.
# 3. Otherwise, the list retrieves a list of jobs for the user or,
#    if specified, the content owner that the user is acting on behalf of.
#    Then it prompts the user to select a job, and then executes case 2 and
#    then case 1.
# Usage examples:
# python retrieve_reports.py --content_owner_id=<CONTENT_OWNER_ID> --local_file=<LOCAL_FILE>
# python retrieve_reports.py --content_owner_id=<CONTENT_OWNER_ID> --job_id=<JOB_ID> --local_file=<LOCAL_FILE>
# python retrieve_reports.py --content_owner_id=<CONTENT_OWNER_ID> --report_url=<REPORT_URL> --local_file=<LOCAL_FILE>
#
###

import argparse
import os

import google.oauth2.credentials
import google_auth_oauthlib.flow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaIoBaseDownload
from google_auth_oauthlib.flow import InstalledAppFlow
from io import FileIO


# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
# the OAuth 2.0 information for this application, including its client_id and
# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
# the {{ Google Cloud Console }} at
# {{ https://cloud.google.com/console }}.
# Please ensure that you have enabled the YouTube Data API for your project.
# For more information about using OAuth2 to access the YouTube Data API, see:
#   https://developers.google.com/youtube/v3/guides/authentication
# For more information about the client_secrets.json file format, see:
#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
CLIENT_SECRETS_FILE = 'client_secret.json'

# This OAuth 2.0 access scope allows for read access to YouTube Analytics
# monetary reports for the authenticated user's account. Any request that
# retrieves earnings or ad performance metrics must use this scope.
SCOPES = ['https://www.googleapis.com/auth/yt-analytics-monetary.readonly']
API_SERVICE_NAME = 'youtubereporting'
API_VERSION = 'v1'

# Authorize the request and store authorization credentials.
def get_authenticated_service():
  flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
  credentials = flow.run_console()
  return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)

# Remove keyword arguments that are not set.
def remove_empty_kwargs(**kwargs):
  good_kwargs = {}
  if kwargs is not None:
    for key, value in kwargs.iteritems():
      if value:
        good_kwargs[key] = value
  return good_kwargs

# Call the YouTube Reporting API's jobs.list method to retrieve reporting jobs.
def list_reporting_jobs(youtube_reporting, **kwargs):
  # Only include the onBehalfOfContentOwner keyword argument if the user
  # set a value for the --content_owner argument.
  kwargs = remove_empty_kwargs(**kwargs)

  # Retrieve the reporting jobs for the user (or content owner).
  results = youtube_reporting.jobs().list(**kwargs).execute()

  if 'jobs' in results and results['jobs']:
    jobs = results['jobs']
    for job in jobs:
      print ('Reporting job id: %s\n name: %s\n for reporting type: %s\n'
        % (job['id'], job['name'], job['reportTypeId']))
  else:
    print 'No jobs found'
    return False

  return True

# Call the YouTube Reporting API's reports.list method to retrieve reports created by a job.
def retrieve_reports(youtube_reporting, **kwargs):
  # Only include the onBehalfOfContentOwner keyword argument if the user
  # set a value for the --content_owner argument.
  kwargs = remove_empty_kwargs(**kwargs)

  # Retrieve available reports for the selected job.
  results = youtube_reporting.jobs().reports().list(
    **kwargs
  ).execute()

  if 'reports' in results and results['reports']:
    reports = results['reports']
    for report in reports:
      print ('Report dates: %s to %s\n       download URL: %s\n'
        % (report['startTime'], report['endTime'], report['downloadUrl']))


# Call the YouTube Reporting API's media.download method to download the report.
def download_report(youtube_reporting, report_url, local_file):
  request = youtube_reporting.media().download(
    resourceName=' '
  )
  request.uri = report_url
  fh = FileIO(local_file, mode='wb')
  # Stream/download the report in a single request.
  downloader = MediaIoBaseDownload(fh, request, chunksize=-1)

  done = False
  while done is False:
    status, done = downloader.next_chunk()
    if status:
      print 'Download %d%%.' % int(status.progress() * 100)
  print 'Download Complete!'


# Prompt the user to select a job and return the specified ID.
def get_job_id_from_user():
  job_id = raw_input('Please enter the job id for the report retrieval: ')
  print ('You chose "%s" as the job Id for the report retrieval.' % job_id)
  return job_id

# Prompt the user to select a report URL and return the specified URL.
def get_report_url_from_user():
  report_url = raw_input('Please enter the report URL to download: ')
  print ('You chose "%s" to download.' % report_url)
  return report_url

if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument('--content_owner', default='',
      help='ID of content owner for which you are retrieving jobs and reports')
  parser.add_argument('--job_id', default=None,
      help='ID of the job for which you are retrieving reports. If not ' +
           'provided AND report_url is also not provided, then the script ' +
           'calls jobs.list() to retrieve a list of jobs.')
  parser.add_argument('--report_url', default=None,
      help='URL of the report to retrieve. If not specified, the script ' +
           'calls reports.list() to retrieve a list of reports for the ' +
           'selected job.')
  parser.add_argument('--local_file', default='yt_report.txt',
      help='The name of the local file where the downloaded report will be written.')
  args = parser.parse_args()

  youtube_reporting = get_authenticated_service()
  try:
    # If the user has not specified a job ID or report URL, retrieve a list
    # of available jobs and prompt the user to select one.
    if not args.job_id and not args.report_url:
      if list_reporting_jobs(youtube_reporting,
                             onBehalfOfContentOwner=args.content_owner):
        args.job_id = get_job_id_from_user()

    # If the user has not specified a report URL, retrieve a list of reports
    # available for the specified job and prompt the user to select one.
    if args.job_id and not args.report_url:
      retrieve_reports(youtube_reporting,
                       jobId=args.job_id,
                       onBehalfOfContentOwner=args.content_owner)
      args.report_url = get_report_url_from_user()

    # Download the selected report.
    if args.report_url:
      download_report(youtube_reporting, args.report_url, args.local_file)
  except HttpError, e:
    print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)