Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Von XML-Feeds zur Content ID API migrieren

Hinweis: Die YouTube Content ID API ist für die Verwendung durch YouTube-Inhaltspartner vorgesehen und nicht für alle Entwickler oder YouTube-Nutzer zugänglich. Wenn die YouTube Content ID API nicht als einer der Dienste aufgeführt ist, die in der Google API Console aufgeführt sind, rufe die YouTube-Hilfe auf, um mehr über das YouTube-Partnerprogramm zu erfahren.

In diesem Leitfaden wird erläutert, wie YouTube-Content-Partner von XML-Content-Feeds zur YouTube Content ID API migrieren können, um Inhalte in das Rechteverwaltungssystem von YouTube aufzunehmen.

Übersicht

Um das System zur Verwaltung von Content ID-Rechten von YouTube nutzen zu können, musst du YouTube Metadaten, Informationen zu Eigentumsrechten, Richtlinieneinstellungen und Referenzmaterial für deine Inhalte zur Verfügung stellen.

YouTube bietet eine Vielzahl von Optionen für die Übermittlung deiner Asset-Daten. Partner, die regelmäßig viele Inhalte hochladen, verwenden oft eine Batch-Upload-Methode, bei der sie ihre Asset-Informationen entweder mit dem DDEX-Feed von YouTube oder einer von YouTube bereitgestellten Tabellenvorlage angeben. Alternativ bietet die YouTube Content ID API eine präzisere Steuerung des Uploadvorgangs.

Mit der API erstellen Sie Assets und andere Ressourcen einzeln, im Gegensatz zur Batchverarbeitung von XML-Feeds und Tabellen. Der individuelle Ansatz der API kann zu schnelleren und zuverlässigeren Uploads führen. Du verwaltest den Uploadprozess auf transaktionale Weise, überwachst den Erfolg einzelner Aktionen und reagierst sofort auf auftretende Probleme. Du kannst dein Content-Management-System mit von YouTube generierten IDs aktualisieren, sobald diese verfügbar sind, anstatt einen Batch-Auftrag zur Nachbearbeitung zu verwenden.

In diesem Dokument wird beschrieben, wie du die YouTube Content ID API verwenden kannst, um deine Inhalte im Rechteverwaltungssystem von YouTube zu definieren. Dabei wird davon ausgegangen, dass du deine Assets derzeit über den DDEX-Feed von YouTube definierst. Außerdem wird erläutert, wie du die Funktionen des XML-Content-Feeds mithilfe der API reproduzieren kannst. Genauer gesagt, wird ein Beispiel für einen XML-Content-Feed verwendet und die API-Befehle mit der gleichen Wirkung werden mithilfe der Python-Client-Bibliothek ermittelt.

Möglichkeiten zur Übermittlung von Asset-Daten an YouTube

Das Ergebnis der Verwendung des XML-Contentfeeds oder der Content ID API ist dasselbe: Du erstellst oder aktualisierst in deinem Partnerkonto Ressourcen zur Rechteverwaltung auf YouTube. In einigen Fällen erstellen (oder aktualisieren) Sie auch YouTube-Videos.

Der XML-Content-Feed und die API gehen die Aufgabe unterschiedlich vor. Mit dem XML-Content-Feed erstellen Sie eine einzelne Datei, die alle Informationen zu den Ressourcen und den Beziehungen zwischen ihnen enthält. YouTube verwendet den Feed als Vorlage, um die tatsächlichen Ressourcen während des Batch-Upload-Prozesses zu erstellen. Mit der API erstellen Sie Ressourcen einzeln statt in Batches. Sie können den Fortschritt und Erfolg jedes einzelnen Ressourcen- und API-Aufrufs überwachen.

Wenn du Ressourcen direkt mithilfe von API-Methoden erstellst, musst du bestimmte Aktionen explizit ausführen, die beim Batch-Upload von YouTube im Hintergrund ausgeführt werden. Vor allem müssen Sie Ihre Mediendateien hochladen und auf Probleme reagieren, indem Sie Aktionen wiederholen oder Fehler melden. Außerdem müssen Sie die Aktionen in der richtigen Reihenfolge ausführen. Du kannst beispielsweise erst Anspruch auf ein Video erheben, nachdem du es erstellt hast.

Jedes der Elemente auf Stammebene im YouTube-XML-Content-Feed-Format entspricht einer Ressource (oder einer Ressourceneigenschaft), die du mithilfe der YouTube-APIs erstellst.

XML-Elemente und entsprechende API-Ressourcen
`<asset>`	`asset`
`<file>`	`videos.fileDetails` (von der YouTube Data API) oder `thumbnail` (von der YouTube Data API) oder `reference`
`<ownership>`	`ownership`
`<rights_admin>`	`assetMatchPolicy` (für Abgleichsrichtlinien) `claims.policy` (für Nutzungsrichtlinien)
`<rights_policy>`	`policy`
`<video>`	`videos` (von der YouTube Data API)
`<video_breaks>`	`videoAdvertisingOption.adbreaks[ ]`
`<ad_policy>`	`videoAdvertisingOption`
`<claim>`	`claim`
`<playlist>`	`playlist` (von der YouTube Data API)
`<relationship>`	Verschiedene

Hinweis: Die YouTube Content ID API unterstützt derzeit keine Untertiteldateien, Trailer oder Album-Artwork-Dateien.

Die Verarbeitung der <relationship>-Elemente verdeutlicht den Unterschied zwischen dem XML-Feed und der API anschaulich.

Ein XML-<relationship>-Element gibt an, dass eine Beziehung zwischen den <item>- und <related_item>-Elementen besteht, gibt jedoch keine Auskunft über die Art dieser Beziehung. Der YouTube-Upload-Prozess leitet die richtige Beziehung von den Objekttypen ab. Eine Beziehung zwischen einem Inhalt und einem Video gibt beispielsweise an, dass YouTube die Videodatei als Referenz für den Inhalt verwenden soll, während eine Beziehung zwischen einer Anzeigenrichtlinie und einem Video die Richtlinie für das Video festlegt.
Mit der YouTube Content ID API verwendest du spezifische API-Ressourcen, die explizit die korrekte Beziehung festlegen. Um ein Video als Referenz für ein Asset zu verwenden, erstellst du eine reference-Ressource. Zum Festlegen der Werberichtlinie für ein Video erstellen Sie eine videoAdvertisingOptions-Ressource. Das Asset muss vorhanden sein, bevor Sie seine Eigenschaften festlegen können.

Asset-Daten über ein Script hochladen

Wenn du Inhaltsdaten mithilfe der APIs hochladen möchtest, musst du ein Skript schreiben, das API-Anfragen senden, Dateien hochladen und Ressourcen zur YouTube-Rechteverwaltung erstellen kann. Dieser Abschnitt enthält eine Anleitung zum Schreiben des Skripts.

Die wichtigsten Schritte sind:

Erstelle ein einfaches Script, das YouTube APIs verwendet.
Fügen Sie Code hinzu, der Mediendateien hochlädt.
Füge Code hinzu, mit dem Ressourcen zur Rechteverwaltung erstellt werden.
Operationalisieren Sie Ihr Skript, damit es mit Ihrem Content Delivery System funktioniert.

Am Ende des Dokuments wird (mit Ausnahme von Schritt 4) ein Codebeispiel bereitgestellt. Der Code ist zwar in Python geschrieben, für andere gängige Programmiersprachen sind jedoch auch Clientbibliotheken verfügbar.

Schritt 1: API-Aufrufe ausführen

In der Anleitung Erste Anfrage senden wird erläutert, wie du ein einfaches Skript programmierst, das YouTube Content API-Anfragen sendet. Das Beispielskript aus dieser Anleitung authentifiziert den Nutzer, autorisiert die Verwendung von API-Anfragen und erstellt Ressourcen für die Interaktion mit der YouTube Content ID API.

Dieses Skript ist die Grundlage des in diesem Beispiel verwendeten Skripts. Wie oben erwähnt, wird in diesem Beispiel jedoch erläutert, wie YouTube-Videos erstellt und Anspruch darauf erhoben wird. Außerdem müssen Sie zum Hochladen von YouTube-Videos die YouTube Data API verwenden. Um das Skript in der Anleitung für den Zugriff auf die YouTube Data API zu aktivieren, musst du die folgenden beiden Ergänzungen hinzufügen:

Autorisieren Sie den Zugriff auf die Uploadfunktion der YouTube Data API, indem Sie den zugehörigen URI zum scope-Parameter im flow_from_clientsecrets-Aufruf hinzufügen (siehe Schritt 2 der Anleitung).

FLOW = flow_from_clientsecrets( 'client_secrets.json ',
           scope='https://www.googleapis.com/auth/youtubepartner https://www.googleapis.com/auth/youtube.upload',
           message= 'error message')

Erstelle eine Ressource für die Interaktion mit der YouTube Data API (ab Schritt 3 der Anleitung).

service = build("youtubePartner", "v1", http=http, static_discovery=False)
dataApi = build("youtube", "v3", http=http)

Schritt 2: Videodateien hochladen

Im nächsten Schritt fügen Sie eine Funktion hinzu, die Videodateien hochlädt. Für maximale Zuverlässigkeit verwenden Sie ein Protokoll für fortsetzbare Uploads. Mit diesem Protokoll können Sie einen Uploadvorgang nach einer Netzwerkunterbrechung oder einem anderen Übertragungsfehler fortsetzen. So sparen Sie bei Netzwerkausfällen Zeit und Bandbreite.

In der Anleitung zum Hochladen eines Videos in der Dokumentation zur YouTube Data API findest du ein Beispiel-Uploadskript: upload_video.py. Aktualisieren Sie das einfache Script aus Schritt 1, indem Sie die Funktion resumable_upload aus upload_video.py hinzufügen. Außerdem müssen Sie die import-Anweisungen und Variablendefinitionen hinzufügen, von denen die Funktion abhängt.

Schritt 3: Ressourcen zur YouTube-Rechteverwaltung erstellen

Nachdem du das Grundgerüst geschaffen hast, kannst du den Code hinzufügen, mit dem YouTube-Assets, -Videos und zugehörige Ressourcen erstellt werden.

Die Reihenfolge, in der Sie Ressourcen erstellen, ist wichtig. Du musst beispielsweise einen Inhalt erstellen und ein Video hochladen, bevor du Anspruch auf das Video für den Inhalt erheben kannst.

Die allgemeine Reihenfolge der Vorgänge für Film-, TV-, Musikvideo- und Webvideo-Assets sieht folgendermaßen aus:

Asset-Ressource erstellen (assets.insert)
Eigentumsrechte (ownership.update) und Abgleichsrichtlinie (assetMatchPolicy.update) des Assets aktualisieren
Videoressource (videos.insert) erstellen, ihre Metadaten festlegen und die Mediendatei hochladen
Anzeigenrichtlinien des Videos aktualisieren (videoAdvertisingOptions.update)
Im Namen des Assets Anspruch auf das Video erheben (claims.insert)
Erstelle eine Referenz für den Inhalt unter Verwendung des Videos mit Ansprüchen (references.insert)

Die allgemeine Reihenfolge der Vorgänge für Tonaufnahmen oder Nur-Referenz-Assets ist die gleiche, wobei die Schritte 3 bis 5 ausgelassen werden:

Asset-Ressource erstellen (assets.insert)
Eigentumsrechte (ownership.update) und Abgleichsrichtlinie (assetMatchPolicy.update) des Assets aktualisieren
Erstelle eine Referenz für das Asset (references.insert) und lade die Mediendatei hoch

Der Rest dieses Abschnitts enthält Details zu jedem dieser Schritte, wobei der Beispiel-XML-Feed mit dem entsprechenden Code im Beispielskript verglichen wird.

Schritt 3.1: Asset erstellen

Der erste Aufruf erfolgt an die Methode assets.insert der API. Sie entspricht diesem Teil des XML-Feeds:

<asset type="web">
  <title>Broadcast Yourself!: Using the YouTube Live APIs to stream to the world</title>
  <description>See a preview of the Google I/O presentation.</description>
</asset>

Um diese Werte in einer asset-Ressource anzugeben, legen Sie die folgenden Attributwerte fest:

{
  "type": "web",
  "metadata": {
    "title": "Broadcast Yourself!: Using the YouTube Live APIs to stream to the world",
    "description": "See a preview of the Google I/O presentation."
  }
}

Extrahieren Sie das Attribut id aus der Ressource, die die API zurückgibt. Diese Eigenschaft gibt die Inhalts-ID an, die YouTube zur eindeutigen Identifizierung des Inhalts zugewiesen hat. Dieser Wert ist in mehreren nachfolgenden API-Aufrufen erforderlich und wird weiter unten in dieser Dokumentation als assetId bezeichnet.

Schritt 3.2: Eigentumsrechte am Asset aktualisieren

Nachdem du ein Asset erstellt hast, legst du mit der ownership.update-Methode der API die Eigentumsrechte dafür fest. Dieser Schritt entspricht diesem Teil des XML-Feeds:

<ownership/>
<relationship>
  <item path="/feed/asset[1]"/>
  <related_item path="/feed/ownership[1]"/>
</relationship>

In der XML-Datei wird ein leeres <ownership>-Tag verwendet, das angibt, dass du die weltweiten Eigentumsrechte an den Inhalten besitzt.

In Ihrer API-Anfrage wird der Anfrageparameter assetId auf die in Schritt 1 abgerufene assetId gesetzt. Außerdem wird eine ownership-Ressource mit den folgenden Attributwerten angegeben:

assetId (Anfrageparameter): Legen Sie als Wert die in Schritt 1 abgerufene assetId fest.
general[0].ratio: 100
general[0].owner: "your_content_owner_name"
general[0].type: "exclude"
general[0].territories: []

{
  "general": [
    "ratio": 100,
    "owner": "your_content_owner_name",
    "type": "exclude",
    "territories": []
  ]
}

Diese Eigenschaften weisen darauf hin, dass der angegebene Rechteinhaber – du musst your_content_owner_name durch den Namen deines tatsächlichen Rechteinhabers ersetzen – zu 100% (general[0].ratio) des gesamten Contents gehört. Diese ownership-Ressource gibt an, dass der Rechteinhaber überall mit Ausnahme von (general[0].type) der angegebenen Liste der Gebiete (general[0].territories) der Inhaber des Inhalts ist. Da der Wert dieser Property jedoch eine leere Liste ist, werden keine Gebiete ausgeschlossen.

Schritt 3.3: Abgleichsrichtlinie des Assets festlegen

Das Rechteverwaltungssystem von YouTube bietet zwei Möglichkeiten, eine Abgleichsrichtlinie mit einem Inhalt oder eine Nutzungsrichtlinie mit einem Video mit Ansprüchen zu verknüpfen:

Zuvor gespeicherte Richtlinie verwenden. Bei dieser Methode verwendest du die API, um deine gespeicherten Richtlinien abzurufen, die gewünschte Richtlinie zu finden und dann die eindeutige ID dieser Richtlinie anzugeben, wenn du die Abgleichsrichtlinie eines Assets festlegst oder einen Anspruch erstellst.
Definiere beim Erstellen des Assets oder Anspruchs eine policy-Ressource. In diesem Fall wird die Richtlinienressource nicht gespeichert und kann daher nicht auf andere Assets oder Ansprüche angewendet werden.

Wir empfehlen, die erste Methode zu verwenden, die auf gespeicherten Richtlinien basiert. Ein wichtiger Vorteil dieser Methode besteht darin, dass sich deine Änderung bei der Aktualisierung einer gespeicherten Richtlinie automatisch auf alle Inhalte und Ansprüche auswirkt, für die diese Richtlinie verwendet wird.

In den Codebeispielen in diesem Dokument wird jedoch die zweite Methode verwendet, um die Abgleichsrichtlinie für das neue Asset mithilfe der API-Methode assetMatchPolicy.update festzulegen. (In diesem Dokument wird auch die zweite Methode verwendet, um die Nutzungsrichtlinie festzulegen, die definiert wird, wenn auf das Video Anspruch erhoben wird.) Im Dokument wird der zweite Ansatz verwendet, da die Namen gespeicherter Richtlinien je nach Partner variieren können. Dieser Ansatz sorgt dafür, dass für alle der gleiche Code funktioniert.

Dieser Schritt entspricht diesem Teil des XML-Feeds:

<rights_policy>
  <name>Monetize developer videos</name>
</rights_policy>
<rights_admin owner="True" type="match"/>
<relationship>
  <item path="/feed/rights_admin[1]"/>
  <item path="/feed/rights_policy[1]"/>
  <related_item path="/feed/asset[1]"/>
</relationship>

In Ihrer API-Anfrage wird der Parameter assetId auf den in Schritt 1 abgerufenen assetId gesetzt. Außerdem wird eine assetMatchPolicy-Ressource gesendet, die die unten aufgeführten Attributwerte festlegt:

{
  "rules": [
    {
      "action": "monetize",
      "conditions": {
        "requiredTerritories": {
          "type": "exclude",
          "territories": []
        }
      }
    }
  ]
}

Das folgende Beispiel zeigt, wie die Ressource assetMatchPolicy aufgebaut wird, wenn du eine gespeicherte Richtlinie als Abgleichsrichtlinie eines Assets festlegst. Dein Code muss den String PolicyID durch die ID ersetzen, die deine gespeicherte Richtlinie eindeutig identifiziert.

{
  "policyId": "PolicyID"
}

Hinweis:Im XML-Feed werden wie auf der Seite Richtlinien im Content-Manager von YouTube die Richtlinien namentlich angegeben. Verwenden Sie die Methode policies.list, um die ID für eine gespeicherte Richtlinie abzurufen. Richtlinien-IDs variieren von Partner zu Partner, selbst bei den Standardrichtlinien.

Schritt 3.4: Videoressource erstellen und Mediendatei hochladen

Sie laden Ihr Video mit der videos.insert-Methode der Data API hoch. Im Leitfaden zu fortsetzbaren Uploads sind die HTTP-Aufrufe aufgeführt, die du ausführen würdest, um Videos über einen fortsetzbaren Upload hochzuladen. Außerdem unterstützen mehrere unserer API-Clientbibliotheken fortsetzbare Uploads. Im Beispielcode unten wird ein fortsetzbarer Uploadvorgang mit der Google API-Clientbibliothek für Python verwendet.

Dieser Schritt entspricht diesem Teil des XML-Feeds:

<video>
  <title>Broadcast Yourself!: Using the YouTube Live APIs to stream to the world</title>
  <description>See a preview of the Google I/O presentation.</description>
  <genre>Entertainment</genre>
  <keyword>”Google I/O” “YouTube Live APIs”</keyword>
  <public>True</public>
</video>
<file type="video">
  <filename>GOOG_IO_Broadcast_Yourself.mov</filename>
</file>
<relationship>
  <item path="/feed/file[1]"/>
  <related_item path="/feed/video[1]"/>
</relationship>

Wenn Sie benutzerdefinierten Code für die API-Aufrufe schreiben, senden Sie eine erste Anfrage, die die video-Ressource erstellt und eine Upload-URL zurückgibt. Senden Sie dann eine zweite Anfrage zum Hochladen der Daten der Binärdatei des Videos zu dieser URL. Wenn Sie die Python-Clientbibliothek verwenden (wie im Beispiel), senden Sie die Ressource video und die Daten der Binärdatei des Videos in derselben Anfrage.

Um das im XML-Beispiel beschriebene Video zu erstellen, würde Ihre API-Anfrage den Wert des Parameters part auf snippet,status und die Ressource video im Anfragetext die folgenden Eigenschaften festlegen. Der Wert snippet.categoryId (24) entspricht der Kategorie Entertainment. Das ist die Kategorie, die mit dem Video im XML-Feed verknüpft ist. Weitere Informationen zu Videokategorien finden Sie in den Anhängen.

{
  "snippet": {
    "title": "Broadcast Yourself!: Using the YouTube Live APIs to stream to the world",
    "description": "See a preview of the Google I/O presentation.",
    "tags": ["Google I/O", "YouTube Live APIs"],
    "categoryId": 24
  },
  "status": {
    "privacyStatus": "private"
  }
}

Hinweis: Wir empfehlen, den Datenschutzstatus eines Videos beim Hochladen auf private zu setzen und ihn später auf public zu aktualisieren. Wenn du das Video lieber als öffentliches Video hochladen möchtest, setze die status.privacyStatus-Eigenschaft auf public.

Extrahieren Sie das Attribut id aus der Ressource, die die API zurückgibt. Diese Eigenschaft identifiziert die Video-ID, die YouTube zur eindeutigen Identifizierung des Videos zugewiesen hat. Dieser Wert ist in mehreren nachfolgenden API-Aufrufen erforderlich und wird weiter unten in dieser Dokumentation als videoId bezeichnet.

Schritt 3.5: Daten-API abfragen, um festzustellen, wann das Video verarbeitet wurde

Bestimmte Aktionen wie das Erstellen einer Referenz erfordern, dass YouTube dein Video verarbeitet hat. Daher muss im nächsten Schritt des Skripts sichergestellt werden, dass das Video vollständig hochgeladen wurde.

Um den Uploadstatus zu prüfen, rufen Sie die Methode videos.list der Data API auf und legen Sie die folgenden Anfrageparameter fest:

id: videoId (aus dem vorherigen Schritt)
part: „processingDetails“

Die API gibt eine Liste von video-Ressourcen zurück, die genau eine Ressource enthält. Du musst den Wert der processingDetails.processingStatus-Eigenschaft dieser Ressource prüfen, um festzustellen, ob YouTube das Video noch verarbeitet. Der Wert der Property wird in einen anderen Wert als processing geändert, z. B. succeeded oder failed, wenn YouTube die Verarbeitung des Videos abgeschlossen hat.

Im Beispielcode wird alle 12 Sekunden die Methode videos.list aufgerufen, um zu ermitteln, ob die Verarbeitung des Videos abgeschlossen ist. Diese Statusprüfung entspricht keinem Element aus der XML-Datei. Sie stellt eine Aktion dar, die bei einem Batch-Upload bei der Verarbeitung der XML-Datei implizit verarbeitet wird.

Schritt 3.6: Anzeigenrichtlinie festlegen

Sobald YouTube das Video verarbeitet hat, können Sie die Anzeigeneinstellungen für die Ressource „video“ aktualisieren. Rufe die Methode videoAdvertisingOptions.update der Content ID API auf, um die Werberichtlinie für das Video festzulegen. Diese Aktion entspricht diesem Teil des XML-Feeds:

<ad_policy>
  <instream standard="long" trueview="true">
    <prerolls>Allow</prerolls>
    <postrolls>Allow</postrolls>
    <midrolls>Deny</midrolls>
  </instream>
  <overlay>
    <adsense_for_video>Allow</adsense_for_video>
    <invideo>Allow</invideo>
  </overlay>
</ad_policy>
<relationship>
  <item path="/feed/ad_policy[1]"/>
  <related_item path="/feed/video[1]"/>
</relationship>

Die in diesem Beispiel gezeigte Richtlinie ermöglicht es YouTube, TrueView-In-Stream-Anzeigen oder Overlay-Anzeigen zu schalten, einschließlich "lang"-Anzeigen 30-sekündige Anzeigen, die am Anfang (Pre-Roll) oder am Ende (Post-Roll) des Videos angezeigt werden.

Senden Sie zum Festlegen der Anzeigenrichtlinie eine Anfrage, mit der der Parameter videoId auf den zuvor abgerufenen videoId gesetzt wird. Der Text der Anfrage ist eine videoAdvertisingOptions-Ressource, die die folgenden Attribute festlegt:

{
  "breakPosition": ["preroll", "postroll"],
  "adFormats": ["long", "trueview_instream", "overlay"]
}

Schritt 3.7: Anspruch auf das Video erheben

In diesem Schritt erhebst du Anspruch auf das von dir hochgeladene Video und legst die Nutzungsrichtlinie für das Video fest, indem du die Methode claims.insert der Content ID API aufrufst. Dieser Schritt entspricht diesem Teil des XML-Feeds:

<rights_policy>
  <rule action="monetize"/>
</rights_policy>
<rights_admin owner="True" type="match"/>
<claim type="audiovisual"
       asset="/feed/asset[1]"
       rights_admin="/feed/rights_admin[1]"
       rights_policy="/feed/rights_policy[1]"
       video="/feed/video[1]"/>

Wie bei der Abgleichsrichtlinie von Assets definiert das Beispielskript eine einmalige Richtlinie, anstatt eine gespeicherte Richtlinie mit dem Video zu verknüpfen. Wie bereits erwähnt, kannst und wird dir jedoch empfohlen, beim Festlegen von Nutzungs- und Abgleichsrichtlinien gespeicherte Richtlinien zu verwenden.

Legen Sie in der claim-Ressource, die Sie mit Ihrer Anfrage senden, die Attribute fest, die in der folgenden Ressource angezeigt werden. Die Strings assetId und videoId müssen durch die Werte ersetzt werden, die das Skript aus den vorherigen Schritten abgerufen hat.

{
  "assetId": assetId,
  "videoId": videoId,
  "contentType": "audiovisual",
  "policy": {
    "rules": [
      {
        "action": "monetize"
      }
    ]
  }
}

Extrahieren Sie das Attribut id aus der Ressource, die die API zurückgibt. Diese Property gibt die Anspruchs-ID an, die YouTube zur eindeutigen Identifizierung des Anspruchs zugewiesen hat. Dieser Wert ist in den nachfolgenden API-Aufrufen erforderlich und wird weiter unten in dieser Dokumentation als claimId bezeichnet.

Schritt 3.8: Referenz erstellen

Verwende die Methode references.insert der Content ID API, um eine Referenz für das Content ID-System zu erstellen. Du kannst eine Referenz mit einem Video mit Ansprüchen als Referenzinhalt erstellen oder eine Referenzdatei im Rahmen des API-Aufrufs hochladen. Wenn du eine Referenz aus einem Video mit Ansprüchen erstellen, muss der Anspruch wie im Beispielskript bereits vorhanden sein.

Legen Sie in der API-Anfrage den Anfrageparameter claimId auf den Wert claimid fest, den Sie im vorherigen Schritt erhalten haben. Senden Sie auch eine reference-Ressource, die die unten gezeigten Attribute festlegt:

{
  "contentType": "audiovisual"
}

Wenn du ein reines Referenz-Asset ohne ein Video mit Ansprüchen erstellen möchtest, musst du an der obigen Anfrage die folgenden Änderungen vornehmen:

Anfrageparameter claimId weglassen
Fügen Sie der hochgeladenen Ressource reference das Attribut assetId hinzu.
Lade die Referenzdatei als media_body der API-Anfrage hoch.

Schritt 3.9: Video veröffentlichen

Wenn du die Best Practices befolgt und den Datenschutzstatus deines Videos beim Erstellen auf private gesetzt hast, kannst du den Datenschutzstatus nach dem Upload zu public ändern. Verwende die videos.list- und videos.update-Methoden der YouTube Data API, um die video-Ressource für dein neu hochgeladenes Video abzurufen und zu aktualisieren.

Rufen Sie zuerst die Methode videos.list der Data API mit den folgenden Anfrageparametern auf:

part=status
id=videoId

Diese Methode gibt eine Liste mit einer Ressource zurück, die das Video mit dem angegebenen videoId beschreibt. Ändern Sie den Wert des Attributs status.privacyStatus dieser Ressource in public und rufen Sie dann die Methode videos.update der Data API auf. Legen Sie den folgenden Anfrageparameter fest:

part=status

Der Anfragetext enthält die geänderte Videoressource.

Schritt 4: Content Delivery System einbinden

Der Beispielcode in den Anhängen enthält die spezifischen Metadaten für die Ressourcen direkt im Skript. In der Praxis möchten Sie das Skript wahrscheinlich in Ihr Content-Management-System integrieren. Um ein umfassenderes System zur Inhaltsübermittlung zu erhalten, können Sie folgende Schritte hinzufügen:

Ermittle in deinem Content-Management-System Assets, die hinzugefügt oder aktualisiert werden müssen.
Rufen Sie Asset-Metadaten aus dem Content-Management-System ab.
Aktualisiere das Content-Management-System mit von YouTube bereitgestellten IDs für die erstellten Assets, Videos, Referenzen und Ansprüche sowie mit Zeitstempeln, um zu erfassen, wann die Assets zuletzt aktualisiert wurden.

Anhang

Beispiel für eine XML-Feed-Datei

<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.youtube.com/schemas/cms/2.0"
      notification_email="someone@example.com"
      channel="your_channel" content_owner="your_name">
 <asset type="web">
   <title>Broadcast Yourself!: Using the YouTube Live APIs to stream to the world</title>
   <description>See a preview of the Google I/O presentation.</description>
 </asset>
 <video>
   <title>Broadcast Yourself!: Using the YouTube Live APIs to stream to the world</title>
   <description>See a preview of the Google I/O presentation.</description>
   <genre>Entertainment</genre>
   <keyword>”Google I/O” “YouTube Live APIs”</keyword>
   <public>True</public>
 </video>
 <file type="video">
   <filename>GOOG_IO_Broadcast_Yourself.mov</filename>
 </file>
  <relationship>
   <item path="/feed/file[1]"/>
   <related_item path="/feed/video[1]"/>
 </relationship>
 <content_rating system="youtube">L0 N0 S0 V0 D0 F0</content_rating>
 <relationship>
   <item path="/feed/content_rating[1]"/>
   <related_item path="/feed/video[1]"/>
 </relationship>
 <ownership/>
 <relationship>
   <item path="/feed/asset[1]"/>
   <related_item path="/feed/ownership[1]"/>
 </relationship>
 <rights_policy>
   <name>Monetize developer videos</name>
 </rights_policy>
 <rights_admin owner="True" type="match"/>
 <relationship>
   <item path="/feed/rights_admin[1]"/>
   <item path="/feed/rights_policy[1]"/>
   <related_item path="/feed/asset[1]"/>
 </relationship>
 <ad_policy>
   <instream standard="long" trueview="true">
     <prerolls>Allow</prerolls>
     <postrolls>Allow</postrolls>
     <midrolls>Deny</midrolls>
   </instream>
   <overlay>
     <adsense_for_video>Allow</adsense_for_video>
     <invideo>Allow</invideo>
   </overlay>
 </ad_policy>
 <relationship>
   <item path="/feed/ad_policy[1]"/>
   <related_item path="/feed/video[1]"/>
 </relationship>
 <claim type="audiovisual" asset="/feed/asset[1]" rights_admin="/feed/rights_admin[1]" rights_policy="/feed/rights_policy[1]" video="/feed/video[1]"/>
</feed>

Beispielskript

Im Beispielcode wird die Google API-Clientbibliothek für Python verwendet.

#!/usr/bin/python2.6
# -*- coding: utf-8 -*-
#
# Copyright (C) 2012 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.

"""Simple command-line sample for YouTube Content ID API.

Command-line application that retrieves the information
about given content owner.

Usage:
  $ python yt_partner_api.py --file="/path/to/reference/file"

You can also get help on all the command-line flags the program understands
by running:

  $ python yt_partner_api.py --help

To get detailed log output run:

  $ python yt_partner_api.py --logging_level=DEBUG \
    --file="/path/to/reference/file"
"""

import gflags
import httplib
import httplib2
import json
import logging
import sys
import time
import os

from apiclient.discovery import build
from apiclient.errors import HttpError
from apiclient.http import MediaFileUpload
from oauth2client.file import Storage
from oauth2client.client import AccessTokenRefreshError
from oauth2client.client import flow_from_clientsecrets
from oauth2client.tools import run

# Explicitly tell the underlying HTTP transport library not to retry, since
# we are handling retry logic ourselves.
httplib2.RETRIES = 1

# Maximum number of times to retry before giving up.
MAX_RETRIES = 10

# Always retry when these exceptions are raised.
RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib.NotConnected,
  httplib.IncompleteRead, httplib.ImproperConnectionState,
  httplib.CannotSendRequest, httplib.CannotSendHeader,
  httplib.ResponseNotReady, httplib.BadStatusLine)

# Always retry when an apiclient.errors.HttpError with one of these status
# codes is raised.
RETRIABLE_STATUS_CODES = [500, 502, 503, 504]

#httplib2.debuglevel = 4
FLAGS = gflags.FLAGS

# 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 API Console at
# https://console.cloud.google.com/.
# See the "Registering your application" instructions for an explanation
# of how to find these values:
# https://developers.google.com/youtube/partner/guides/registering_an_application
# For more information about using OAuth2 to access Google APIs, please visit:
#   https://developers.google.com/accounts/docs/OAuth2
# For more information about the client_secrets.json file format, please visit:
#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
CLIENT_SECRETS = 'client_secrets.json'

# Helpful message to display if the CLIENT_SECRETS file is missing.
MISSING_CLIENT_SECRETS_MESSAGE = """
WARNING: Please configure OAuth 2.0

To make this sample run you will need to populate the client_secrets.json file
found at:

%s

with information from the API Console
<https://console.cloud.google.com/ >

""" % os.path.join(os.path.dirname(__file__), CLIENT_SECRETS)

# Flags definition
#
# The gflags module makes defining command-line options easy for
# applications. Run this program with the '--help' argument to see
# all the flags that it understands.
gflags.DEFINE_enum('logging_level', 'ERROR',
    ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
    'Set the level of logging detail.')

gflags.DEFINE_string('file', None, 'The video file to upload.')

def resumable_upload(insert_request):
  response = None
  error = None
  retry = 0
  while response is None:
    try:
      print "Uploading file..."
      status, response = insert_request.next_chunk()
      if 'id' in response:
        print "'video id: %s was successfully uploaded." % (response['id'])
        return response['id']
      else:
        exit("The upload failed with an unexpected response: %s" % response)
    except HttpError, e:
      if e.resp.status in RETRIABLE_STATUS_CODES:
        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
                                                             e.content)
      else:
        raise
    except RETRIABLE_EXCEPTIONS, e:
      error = "A retriable error occurred: %s" % e

    if error is not None:
      print error
      retry += 1
      if retry > MAX_RETRIES:
        exit("No longer attempting to retry.")

      max_sleep = 2 ** retry
      sleep_seconds = random.random() * max_sleep
      print "Sleeping %f seconds and then retrying..." % sleep_seconds
      time.sleep(sleep_seconds)
  return None

def createRequest(service, resource, operation, **kwargs):
  request = getattr(service, resource)()
  request = getattr(request, operation)(**kwargs)
  return request

def executeOperation(service, resource, operation, **kwargs):
  request = getattr(service, resource)()
  request = getattr(request, operation)(**kwargs)
  return_value = request.execute()
  print json.dumps(return_value)
  return return_value

def main(argv):
  # Let the gflags module process the command-line arguments
  try:
    argv = FLAGS(argv)
  except gflags.FlagsError, e:
    print '%s\nUsage: %s ARGS\n%s' % (e, argv[0], FLAGS)
    sys.exit(1)

  # Set up a Flow object to be used if we need to authenticate.
  FLOW = flow_from_clientsecrets(CLIENT_SECRETS,
             scope='https://www.googleapis.com/auth/youtubepartner https://www.googleapis.com/auth/youtube.upload',
             message=MISSING_CLIENT_SECRETS_MESSAGE)

  # Set the logging according to the command-line flag
  logging.getLogger().setLevel(getattr(logging, FLAGS.logging_level))

  # If the Credentials don't exist or are invalid run through the native client
  # flow. The Storage object will ensure that if successful the good
  # Credentials will get written back to a file.
  storage = Storage('yt_partner_api.dat')
  credentials = storage.get()
  if credentials is None or credentials.invalid:
    credentials = run(FLOW, storage)

  # Create an httplib2.Http object to handle our HTTP requests and authorize it
  # with our good Credentials.
  http = httplib2.Http()
  http = credentials.authorize(http)

  # Create service and retrieve content owner service.
  partnerApi = build("youtubePartner", "v1", http=http)
  dataApi = build("youtube", "v3", http=http)

  try:
    title = 'Top Ten Ridiculous test #u',
    monetize_policy = {'rules': [{'action': 'monetize'}]}

    # Create the asset
    kwargs = {}
    metadata = {'title': title,
                'description': 'Wow this is a really long description'}
    kwargs['body'] = {'metadata': metadata, 'type': 'web'}
    insert_asset = executeOperation(partnerApi, 'assets', 'insert', **kwargs)
    asset_id = insert_asset['id']
    print 'Asset ID is ' + asset_id

    # Set asset ownership
    kwargs = {'assetId': asset_id}
    ownership = {'ratio': 100,
                 'owner': 'psomusictest',
                 'type': 'exclude',
                 'territories': []}
    body = {'general': [ownership], 'id': asset_id}
    kwargs['body'] = body
    set_ownership = executeOperation(partnerApi, 'ownership', 'update',
                                     **kwargs)

    # Set match policy
    kwargs = {'assetId': asset_id, 'body': monetize_policy}
    set_match_policy = executeOperation(partnerApi, 'assetMatchPolicy',
                                        'update', **kwargs)

    # Insert video using resumable upload
    snippet = {'title': title,
               'description': 'Wow this is a really long description',
               'tags': ['fizzle', 'sizzle', 'razzle dazzle'],
               'categoryId': '24'}
    status = {'privacyStatus': 'private'}
    body = { 'snippet': snippet, 'status': status }
    kwargs = {'part': 'snippet,status',
              'body': body,
              'media_body': MediaFileUpload(FLAGS.file,
                                            chunksize=-1,
                                            resumable=True)}

    insert_video = createRequest(dataApi, 'videos', 'insert', **kwargs)
    video_id = resumable_upload(insert_video)

    if not video_id:
      print 'video upload failed, so the rest of this exercise is pointless'
      return
   # Poll to see when video is processed
    kwargs = {'id': video_id, 'part': 'processingDetails'}
    check_video_status = createRequest(dataApi, 'videos', 'list', **kwargs)
    video_processed = False
    sleep_seconds = 12
    while not video_processed:
      status = check_video_status.execute()
      processingDetails = status['items'][0]['processingDetails']
      if processingDetails['processingStatus'] != 'processing':
        print 'hooray, it ' + processingDetails['processingStatus']
        video_processed = True
      elif not 'processingProgress' in processingDetails:
        time.sleep(sleep_seconds)
      else:
        print ('so far, we processed %d/%d parts' % (
            processingDetails['processingProgress']['partsProcessed'],
            processingDetails['processingProgress']['partsTotal']))
        time.sleep(sleep_seconds)

    # Claim the video
    body = {'assetId': asset_id,
            'videoId': video_id,
            'policy': monetize_policy,
            'contentType': 'audiovisual'}
    kwargs = {'body': body}
    claim_video = executeOperation(partnerApi, 'claims', 'insert', **kwargs)
    claim_id = claim_video['id']
    print 'claim ID is ' + claim_id

    # Create the reference
    body = {'assetId': asset_id,
            'videoId': video_id,
            'contentType': 'audiovisual'}
    kwargs = {'claimId': claim_id, 'body': body}
    create_reference = executeOperation(partnerApi, 'references', 'insert',
                                        **kwargs)

    # Set ad policy (update video advertising options)
    ads = {'breakPosition': ['preroll','postroll'],
           'adFormats': ['standard_instream','trueview_instream','overlay']}
    kwargs = {'videoId': video_id, 'body': ads}
    ads = executeOperation(partnerApi, 'videoAdvertisingOptions',
                           'update', **kwargs)

    #9 Update video's privacy status to public
    kwargs = {'part': 'status', 'id': video_id}
    video = executeOperation(dataApi, 'videos', 'list', **kwargs)
    video['items'][0]['status']['privacyStatus'] = 'public'
    kwargs = {'part': 'status', 'body': video['items'][0]}
    video = executeOperation(dataApi, 'videos', 'update', **kwargs)

  except AccessTokenRefreshError:
    print ("The credentials have been revoked or expired, please re-run"
      " the application to re-authorize")

if __name__ == '__main__':
  main(sys.argv)

Andere API-Aktionen

Liste von Videokategorien mithilfe der Data API abrufen

Im Beispielcode wird der Wert der Eigenschaft snippet.categoryID auf 24 gesetzt, was der Spalte "Entertainment" entspricht. Genre Wenn Ihr Skript nach der ID für ein bestimmtes Genre suchen soll (anstatt die Kategorie-IDs hartzucodieren), rufen Sie die Methode videoCategories.list der Data API auf und legen Sie die folgenden Anfrageparameter fest:

part=snippet
regionCode=US (Sie können für regionCode einen anderen Wert festlegen, um Videokategorien für ein anderes Land abzurufen)

Für jede videoCategory-Ressource in der API-Antwort würden Sie den Wert des Attributs snippet.title prüfen, um einen Kategorienamen zu identifizieren, und das Attribut id aus der gewünschten Kategorie extrahieren. So sieht die Ressource videoCategory für die Ressource "Entertainment" aus Kategorie:

{
  "id": "24",
  "kind": "youtube#videoCategory",
  "etag": "\"idnvT0N6oxG_2o6LCWUdZsqtqtk/I5rstjIK5PCItZFyWV-uw\"",
  "snippet": {
    "channelId": "UCBR8-60-B28hp2BmDPdntcQ",
    "title": "Entertainment"
  }
}