Migrar dos feeds XML para a API Content ID

Observação: a API Content ID do YouTube é destinada a parceiros de conteúdo do YouTube e não pode ser acessada por todos os desenvolvedores ou usuários do YouTube. Se você não encontrar a API Content ID do YouTube como um dos serviços listados no Console de APIs do Google, consulte a Central de Ajuda do YouTube para saber mais sobre o Programa de Parcerias do YouTube.

Este guia explica como parceiros de conteúdo do YouTube podem migrar de feeds de conteúdo XML para a API do Content ID do YouTube para ingestão de conteúdo no sistema de gerenciamento de direitos do YouTube.

Visão geral

Para se beneficiar com o sistema de gerenciamento de direitos do Content ID do YouTube, você precisa fornecer ao YouTube metadados, informações sobre a propriedade, configurações da política e materiais de referência para seus recursos.

O YouTube oferece várias opções para exibição de dados do recursos. Os parceiros que enviam regularmente muito conteúdo costumam usar um método de upload em lote, especificando as informações dos recursos com o feed DDEX do YouTube ou um modelo de planilha fornecido pelo YouTube. Como alternativa, a API do Content ID do YouTube oferece um controle mais refinado sobre o processo de envio.

Usando a API, você cria recursos, um por um, em contraste com o processamento em lote de feeds XML e planilhas. A abordagem individual da API pode resultar em uploads mais rápidos e mais confiáveis. Você gerencia o processo de upload de modo transacional, monitorando o sucesso de ações individuais e reagindo imediatamente a todas as questões que possam surgir. Você pode atualizar seu sistema de gerenciamento de conteúdo com códigos gerados pelo YouTube à medida que eles se tornam disponíveis, em vez de usar uma tarefa em lote de pós-processamento.

Este documento descreve como usar a API do Content ID do YouTube para definir seus recursos no sistema de gerenciamento de direitos do YouTube. Ele pressupõe que você está definindo seus recursos atualmente usando o feed DDEX do YouTube e explica como recriar a funcionalidade do feed de conteúdo XML usando a API. Mais especificamente, ela usa uma amostra de feed de conteúdo XML e identifica os comandos da API que obtêm o mesmo efeito, usando a biblioteca-cliente Python.

Maneiras de enviar dados de recursos para o YouTube

O resultado final de usar o feed de conteúdo XML ou a API do Content ID é o mesmo: você cria (ou atualiza) recursos de gerenciamento de direitos do YouTube em sua conta de parceiro. Em alguns casos, você também cria (ou atualiza) vídeos do YouTube.

O feed de conteúdo XML e a API abordam a tarefa de forma diferente. Com o feed de conteúdo XML, você cria um único arquivo que contém todas as informações sobre os recursos e as relações entre eles. O YouTube usa o feed como um modelo para criar os recursos reais durante o processo de upload em lote. Usando a API, você cria recursos, um por um, em vez de em um lote. Você pode monitorar o progresso e sucesso de cada recurso individual e chamada de API.

Quando você cria recursos diretamente usando métodos de API, é possível executar explicitamente determinadas ações que o processo de upload em lote do YouTube manipula nos bastidores. Mais notavelmente, você precisa fazer upload de seus arquivos de mídia e responder a questões (repetindo ações ou relatando erros). Também é necessário realizar ações na ordem correta; por exemplo, você não pode reivindicar um vídeo até que o tenha criado.

Cada um dos elementos de nível de raiz no formato de feed de conteúdo XML do YouTube corresponde a um recurso (ou propriedade de recurso) que você cria usando as APIs do YouTube.

Elementos XML e recursos de API correspondentes
<asset> asset
<file> videos.fileDetails (da API YouTube Data) ou
thumbnail (da API YouTube Data) ou
reference
<ownership> ownership
<rights_admin> assetMatchPolicy (para políticas de correspondência)
claims.policy (para políticas de uso)
<rights_policy> policy
<video> videos (da API YouTube Data)
<video_breaks> videoAdvertisingOption.adbreaks[ ]
<ad_policy> videoAdvertisingOption
<claim> claim
<playlist> playlist (da API YouTube Data)
<relationship> Vários

Nota: A API do Content ID do YouTube não suporta atualmente arquivos de legenda, trailers ou arquivos de arte de álbuns.

O tratamento de elementos <relationship> ilustra bem a diferença entre o feed XML e a API.

  • Um elemento XML <relationship> declara que existe uma relação entre os elementos <item> e <related_item>, mas não é explícito sobre a natureza dessa relação. O processo de upload do YouTube infere a relação correta a partir dos tipos de itens. Por exemplo, uma relação entre um recurso e um vídeo indica que o YouTube deve usar o arquivo de vídeo como uma referência para o recurso, enquanto a relação entre uma política de anúncio e um vídeo define a política para o vídeo.

  • Usando a API do Content ID do YouTube, você usa recursos específicos da API que definem explicitamente a relação adequada. Para usar um vídeo como uma referência para um recurso, crie um recurso reference. Para definir a política de anúncios para um vídeo, crie um recurso videoAdvertisingOptions. O recurso deve existir antes que você possa definir suas propriedades.

Fazer upload dos dados do recurso por meio de um script

Para carregar os dados de recursos usando as APIs, você precisa escrever um script que possa enviar solicitações de API, fazer upload de arquivos e criar recursos de gerenciamento de direitos do YouTube. Esta seção fornece um tutorial sobre como escrever o script.

As principais etapas são:

  1. Crie um script básico que use as APIs do YouTube.
  2. Adicionar o código que envia arquivos de mídia.
  3. Adicionar o código que cria recursos de gerenciamento de direitos.
  4. Operacionalizar o script para trabalhar com seu sistema de exibição de conteúdo.

Uma amostra do código é fornecida no final do documento (exceto a etapa 4). Embora o código seja escrito em Python, as bibliotecas de cliente para outras linguagens de programação populares também estão disponíveis.

Etapa 1: fazer chamadas de API

O tutorial Envio de primeira solicitação explica como escrever um script básico que envia solicitações de Content API do YouTube. A amostra de script desse tutorial autentica o usuário, autoriza o uso de solicitações de API e constrói recursos que interagem com a API do Content ID do YouTube.

Esse script serve como base do script usado neste exemplo. No entanto, como mencionado acima, este exemplo explica como criar e reivindicar vídeos do YouTube, e você precisa usar a API de dados do YouTube para fazer upload de vídeos do YouTube. Para ativar o script do tutorial também para acessar também a API de dados do YouTube, faça estas duas adições:

  • Autorize o acesso à funcionalidade de upload na API YouTube Data adicionando o URI dela ao parâmetro scope na chamada flow_from_clientsecrets (a partir da etapa 2 do tutorial).

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

  • Construa um recurso para interagir com a API de dados do YouTube (a partir da Etapa 3 do tutorial). 

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

Etapa 2: fazer upload de arquivos de vídeo

A próxima etapa é adicionar uma função que envia arquivos de vídeo. Para máxima confiabilidade, você usará um protocolo de upload retomável. Este protocolo permite que você retome uma operação de upload após uma interrupção de rede ou outra falha de transmissão, economizando tempo e largura de banda em caso de falhas na rede.

O guia Como enviar um vídeo, na documentação da API YouTube Data, fornece uma amostra de script de upload, upload_video.py. Atualize o script básico da etapa 1 adicionando a função resumable_upload de upload_video.py. Você também precisa adicionar as instruções import e definições de variáveis de que a função depende.

Etapa 3: criar recursos de gerenciamento de direitos do YouTube

Com a estrutura básica em vigor, você está pronto para adicionar o código que cria os recursos, vídeos e recursos associados do YouTube.

A ordem na qual você cria recursos é importante. Por exemplo, você precisa criar um recurso e fazer upload de um vídeo antes de poder reivindicar o vídeo para o recurso.

A ordem geral das operações para filme, TV, vídeo de música e recursos de vídeo da Web é:

  1. Criar o recurso (assets.insert)
  2. Atualizar a propriedade (ownership.update) e a política de correspondência (assetMatchPolicy.update) do recurso
  3. Criar o recurso de vídeo (videos.insert), definindo os metadados e fazendo upload do arquivo de mídia
  4. Atualizar a política de anúncios do vídeo (videoAdvertisingOptions.update)
  5. Reivindique o vídeo em nome do recurso (claims.insert)
  6. Criar uma referência para o recurso usando o vídeo reivindicado (references.insert)

A ordem geral das operações para gravações de som ou recursos somente de referência é a mesma, omitindo as etapas 3 a 5:

  1. Criar o recurso (assets.insert)
  2. Atualizar a propriedade (ownership.update) e a política de correspondência (assetMatchPolicy.update) do recurso
  3. Criar uma referência para o recurso (references.insert) e fazer upload do arquivo de mídia

O restante desta seção fornece detalhes sobre cada uma dessas etapas, comparando a amostra de feed XML para o código correspondente na amostra de script.

Etapa 3.1: criar um recurso

A primeira chamada é para o método assets.insert da API. Ela corresponde a esta parte do feed XML:

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

Para especificar esses valores em um recurso asset, defina os seguintes valores de propriedade:

{
  "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."
  }
}

Extraia a propriedade id do recurso retornado pela API. Essa propriedade identifica o ID do recurso que o YouTube atribuiu para identificar exclusivamente o recurso. Esse valor é necessário em várias chamadas de API subsequentes e é identificado como o assetId posteriormente nesta documentação.

Etapa 3.2: atualizar a propriedade do recurso

Depois de criar um recurso, defina sua propriedade usando o método ownership.update da API. This step corresponds to this portion of the XML feed:

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

O XML usa uma tag <ownership> vazia, que indica que você tem a propriedade global do conteúdo.

Sua solicitação de API definirá o parâmetro de solicitação assetId como o assetId obtido na etapa 1. Ele também especifica um recurso ownership com os valores de propriedade mostrados abaixo:

  • assetId (parâmetro de solicitação): defina como o assetId obtido na etapa 1.
  • 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": []
  ]
}

Essas propriedades indicam que o proprietário do conteúdo especificado (você precisa substituir your_content_owner_name pelo nome real do proprietário do conteúdo) é proprietário de 100% (general[0].ratio) do conteúdo em qualquer lugar. Na verdade, este recurso ownership indica que o proprietário é proprietário do conteúdo em qualquer lugar, exceto (general[0].type) na lista de territórios fornecida (general[0].territories). No entanto, como o valor dessa propriedade é uma lista vazia, nenhum território é excluído.

Etapa 3.3: definir a política de correspondência do recurso

O sistema de gerenciamento de direitos do YouTube oferece duas maneiras de associar uma política de correspondência a um recurso ou uma política de uso a um vídeo reivindicado:

  • Usar uma política salva anteriormente. Nesta abordagem, você usa a API para recuperar suas políticas salvas, encontrar a política que deseja usar e, em seguida, especificar o ID exclusivo dessa política ao definir uma política de correspondência de um recurso ou ao criar uma reivindicação.

  • Defina um recurso policy ao criar o recurso ou a declaração. Neste caso, o recurso da política não é salvo e, portanto, não pode ser aplicado a outros recursos ou reivindicações.

Recomendamos que você use a primeira abordagem, que se baseia em políticas salvas. Um benefício importante desta abordagem é que, se você atualizar uma política salva, sua alteração afetará automaticamente todos os recursos e reivindicações que usam essa política.

No entanto, os exemplos de código neste documento usam a segunda abordagem para definir a política de correspondência para o novo recurso por meio do método assetMatchPolicy.update da API. (este documento também utiliza a segunda abordagem para definir a política de uso, que é definida quando o vídeo é reivindicado). O documento usa a segunda abordagem porque os nomes das políticas salvas podem variar entre os parceiros; esta abordagem garante que o mesmo código funcionará para todos.

This step corresponds to this portion of the XML feed:

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

Sua solicitação de API define o parâmetro assetId como o assetId da etapa 1. Ele também envia um recurso assetMatchPolicy que define os valores das propriedades listados abaixo:

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

O exemplo abaixo mostra como o recurso assetMatchPolicy seria construído se você estivesse definindo uma política salva como a política de correspondência de um recurso. Seu código precisaria substituir a string PolicyID pelo ID que identifica exclusivamente sua política salva.

{
  "policyId": "PolicyID"
}

Observação:o feed XML, como a página Políticas do Gerenciador de conteúdo do YouTube, especifica políticas pelo nome. Para recuperar o ID de uma política salva, use o método policies.list. Os IDs da Política variar de parceiro para parceiro, mesmo para as políticas padrão.

Etapa 3.4: criar um recurso de vídeo e fazer upload do arquivo de mídia

Faça o upload do seu vídeo usando o método videos.insert da API Data. A guia Uploads retomáveis identifica as chamadas HTTP que você faria para enviar vídeos usando um processo de upload retomável, e várias das nossas bibliotecas de cliente API também são compatíveis com uploads retomáveis. O exemplo de código a seguir usa um processo de upload retomável com a biblioteca de cliente Python das APIs do Google.

This step corresponds to this portion of the XML feed:

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

Se estiver criando um código personalizado para fazer as chamadas de API, você vai enviar uma solicitação inicial que cria o recurso video e retorna um URL de upload. Em seguida, vai enviar uma segunda solicitação para enviar os dados do arquivo binário de vídeo para esse URL. Se estiver usando a biblioteca de cliente Python (como no exemplo), você enviará o recurso video e os dados do arquivo binário de vídeo na mesma solicitação.

Para criar o vídeo descrito no exemplo de XML, sua solicitação de API define o valor do parâmetro part como snippet,status e o recurso video no corpo da solicitação define as propriedades a seguir. O valor de snippet.categoryId (24) corresponde à categoria Entertainment, que é associada ao vídeo no feed XML. As categorias de vídeo são discutidas com mais detalhes nos apêndices.

{
  "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"
  }
}

Observação:recomendamos que você defina o status de privacidade de um vídeo como private ao enviá-lo e atualize-o para public posteriormente no processo. Se você preferir enviar o vídeo como público, defina a propriedade status.privacyStatus como public.

Extraia a propriedade id do recurso retornado pela API. Essa propriedade identifica o ID do vídeo que o YouTube atribuiu para identificar exclusivamente o vídeo. Esse valor é necessário em várias chamadas de API subsequentes e é identificado como o videoId posteriormente nesta documentação.

Etapa 3.5: pesquisar a API Data para determinar quando o vídeo foi processado

Algumas ações, como a criação de uma referência, exigem que o YouTube tenha concluído o processamento de seu vídeo. Por essa razão, a próxima etapa do script é assegurar que o upload do vídeo esteja concluído.

Para verificar o status do upload, chame o método videos.list da API Data e defina os seguintes parâmetros de solicitação:

  • id: videoId (da etapa anterior)
  • part: "processingDetails"

A API retorna uma lista de recursos video (contendo exatamente um recurso), e você precisa verificar o valor da propriedade processingDetails.processingStatus desse recurso para determinar se o YouTube ainda está processando o vídeo. O valor da propriedade mudará para algo diferente de processing, como succeeded ou failed, quando o YouTube terminar de processar o vídeo.

O exemplo de código chama o método videos.list a cada 12 segundos para determinar se o processamento do vídeo foi concluído. Esta verificação de status não corresponde diretamente a qualquer elemento do XML, ela representa uma ação que um upload em lote trata implicitamente quando processa o XML.

Etapa 3.6: definir a política de anúncios

Depois que o YouTube tiver processado o vídeo, você poderá atualizar as configurações de anúncios do recurso video. Chame o método videoAdvertisingOptions.update da API Content ID para definir a política de anúncios para o vídeo. Esta ação corresponde a esta parte do feed XML:

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

A política mostrada neste exemplo permite que o YouTube exiba TrueView anúncios in-stream ou anúncios de sobreposição, incluindo anúncios "longos" de 30 segundos no início (precedente) ou no final (final) do vídeo.

Para definir a política de anúncios, envie uma solicitação que defina o parâmetro videoId para o videoId gerado anteriormente. O corpo da solicitação é um recurso videoAdvertisingOptions que define as propriedades mostradas abaixo:

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

Etapa 3.7: reivindicar o vídeo

Nesta etapa, você reivindica o vídeo enviado e define a política de uso dele chamando o método claims.insert da API Content ID. Esta etapa corresponde a esta parte do feed XML:

<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]"/>

Tal como acontece com a política de correspondência do recurso, a amostra de script define uma política única, em vez de associar uma política salva ao vídeo. No entanto, como discutido anteriormente, você pode e é incentivado a utilizar políticas salvas ao definir políticas de uso e de correspondência.

No recurso claim enviado com sua solicitação, defina as propriedades mostradas no recurso abaixo. As strings assetId e videoId precisam ser substituídas pelos valores que o script recebeu nas etapas anteriores.

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

Extraia a propriedade id do recurso retornado pela API. Essa propriedade identifica o ID da reivindicação que o YouTube transferiu para identificar exclusivamente a reivindicação. Esse valor é necessário nas chamadas de API subsequentes e é identificado como o claimId posteriormente nesta documentação.

Etapa 3.8: criar uma referência

Use o método references.insert da API Content ID para criar uma referência para o sistema. Você pode criar uma referência usando um vídeo reivindicado como o conteúdo de referência, ou pode fazer upload de um arquivo de referência como parte da chamada de API. Se você estiver criando uma referência de um vídeo reivindicado, como a amostra de script o faz, a reivindicação já deve existir.

Na solicitação de API, defina o parâmetro de solicitação claimId como o claimid da etapa anterior. Envie também um recurso reference que define as propriedades mostradas abaixo:

{
  "contentType": "audiovisual"
}

Para criar um recurso somente de referência (sem vídeo reivindicado), faça as seguintes mudanças na solicitação acima:

  1. Omitir o parâmetro de solicitação claimId
  2. Adicione a propriedade assetId ao recurso reference enviado.
  3. Faça upload do arquivo de referência como o media_body da solicitação de API.

Etapa 3.9: tornar o vídeo público

Se você seguiu as práticas recomendadas e definiu o status de privacidade do vídeo como private ao criá-lo, poderá alterar o status de privacidade para public após o envio. Use os métodos videos.list e videos.update da API de dados do YouTube para recuperar e atualizar o recurso video para seu vídeo recém-enviado.

Primeiro, chame o método videos.list da API Data com os seguintes parâmetros de solicitação:

  • part=status
  • id=videoId

Esse método retorna uma lista contendo um recurso, que descreve o vídeo com o videoId especificado. Mude o valor da propriedade status.privacyStatus desse recurso para public e, em seguida, chame o método videos.update da API Data. Defina o seguinte parâmetro de solicitação:

  • part=status

O corpo da solicitação é o recurso de vídeo modificado.

Etapa 4: fazer a integração com seu sistema de envio de conteúdo

A amostra de código nos apêndices inclui os metadados específicos para os recursos diretamente no script. Na prática, é provável que você deseje integrar o script com seu sistema de gerenciamento de conteúdo. Para um sistema de exibição de conteúdo mais completo, você pode adicionar etapas, tais como:

  • Pesquisar em seu sistema de gerenciamento de conteúdo para identificar os recursos que precisam ser adicionados ou atualizados.
  • Recuperar metadados de recursos a partir do sistema de gerenciamento de conteúdo.
  • Atualizar o sistema de gerenciamento de conteúdo com IDs fornecidos pelo YouTube para os recursos, vídeos, referências e reivindicações criados, e com timestamps para registrar quando os recursos foram atualizados mais recentemente.

Apêndice

Amostra de arquivo de feed XML

<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.youtube.com/schemas/cms/2.0"
      notification_email="[email protected]"
      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>

Exemplo de script

A amostra de código usa a Biblioteca cliente de APIs do Google para Python.

#!/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)

Outras ações da API

Recuperar uma lista de categorias de vídeos usando a API de dados

O exemplo de código define o valor da propriedade snippet.categoryID como 24, que corresponde ao gênero "Entretenimento". Se você quiser que o script procure o ID de um determinado gênero (em vez de codificar os IDs da categoria), chame o método videoCategories.list da API Data e defina os seguintes parâmetros de solicitação:

  • part=snippet
  • regionCode=US (você pode definir regionCode como um valor diferente para recuperar categorias de vídeo para outro país)

Para cada recurso videoCategory na resposta da API, verifique o valor da propriedade snippet.title para identificar um nome de categoria e extrair a propriedade id da categoria que você quer. Veja como é o recurso videoCategory para a categoria "Entretenimento":

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