Video yükleme

Not: Google Ads API ile video yükleme yalnızca .NET, PHP ve Python istemci kitaplıkları ve REST kullanılarak desteklenir. Diğer istemci kitaplıkları için YouTube Data API v3'ü kullanarak videoları doğrudan yükleyebilir ve elde edilen YouTube video kimliğiyle bir YoutubeVideoAsset oluşturabilirsiniz.

YouTubeVideoUploadService, Google Ads API aracılığıyla videoları doğrudan YouTube'a yüklemenize olanak tanır. Bu videolar daha sonra Maksimum Performans kampanyaları veya Talep Yaratma kampanyaları gibi çeşitli reklam türlerinde video öğeleri oluşturmak için kullanılabilir.

Bu hizmet, YouTube yükleme sürecini yöneterek video reklam oluşturma iş akışını kolaylaştırır ve videoların hesabınızla doğru şekilde ilişkilendirilmesini sağlar.

Temel kavramlar

Başlamadan önce, video yüklemelerinin nasıl yönetildiğini ve geçebilecekleri farklı durumları anlamanız önemlidir.

Uçtan uca iş akışı

Video dosyası yüklemek ve reklamda yayınlamak için dört adımın sırayla uygulanması gerekir:

Adım	Hizmet ve yöntem	Özet
1. Video baytlarını başlatma ve yükleme	CreateYouTubeVideoUpload, YouTubeVideoUploadService hakkında yorum yaptı	YouTubeVideoUpload kaynağı (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}) oluşturmak için video meta verilerini ve ikili program dosyasını yükleyin.
2. Anket işleme durumu	SearchStream, GoogleAdsService hakkında yorum yaptı	state = 'PROCESSED' tarihine kadar you_tube_video_upload sorgusu ve 11 karakterlik YouTube video_id doldurulur.
3. Yeniden kullanılabilir video öğesi oluşturma	MutateAssets, AssetService hakkında yorum yaptı	Öğe kaynak adı (customers/{customer_id}/assets/{asset_id}) almak için YoutubeVideoAsset (youtube_video_id = video_id) oluşturun.
4. Öğeyi kampanyalara veya reklamlara bağlama	AssetGroupAssetService üzerinde MutateAssetGroupAssets veya AdGroupAdService üzerinde MutateAdGroupAds	Öğeyi bir Maksimum Performans AssetGroupAsset (field_type = YOUTUBE_VIDEO) veya Talep Yaratma DemandGenVideoResponsiveAdInfo (videos[].asset) kampanyasına bağlayın.

Kanal sahipliği

Video yüklerken YouTubeVideoUpload kaynağındaki channel_id alanını kullanarak hedef YouTube kanalını belirtebilirsiniz:

• Reklamverene ait (marka) kanal: Reklamverene ait mevcut bir YouTube kanalının channel_id değerini girin. Bu özellik yalnızca kullanıcı kimlik doğrulama akışında desteklenir ve hizmet hesaplarıyla kullanılamaz.
• Google tarafından yönetilen kanal: channel_id atlanırsa video, Google Ads hesabıyla ilişkili, Google tarafından yönetilen bir YouTube kanalına yüklenir.

Yükleme durumları

YouTube video yükleme işleminin yaşam döngüsü state alanı tarafından izlenir. YouTubeVideoUploadState enum'u aşağıdaki durumları tanımlar:

Eyalet	Açıklama
PENDING	Video yükleniyor.
UPLOADED	Video başarıyla yüklendi ve YouTube tarafından işleniyor.
PROCESSED	Video başarıyla işlendi ve kullanıma hazır.
FAILED	Yükleme veya işleme başarısız oldu ve tamamlanamıyor.
REJECTED	Video, doğrulama veya politika nedenleriyle reddedildi.
UNAVAILABLE	Video durumu kullanılamıyor. Video, YouTube'dan kaldırılmış olabilir.

Gizlilik ayarları

video_privacy alanı, yüklenen videoyu kimlerin görebileceğini kontrol eder. YouTubeVideoPrivacy enum'u şunları destekler:

• PUBLIC: Video, YouTube'daki herkes tarafından izlenebilir. (Yalnızca marka kanalları için izin verilir).
• UNLISTED: Video aranamaz ancak bağlantıya sahip olan herkes tarafından görüntülenebilir. Bu, Google tarafından yönetilen kanallar için varsayılan ve tek seçenektir.

Başlık ve açıklamayla ilgili koşullar

Video yükleme işlemi oluştururken YouTubeVideoUpload kaynağındaki video_title ve video_description alanlarını kullanarak meta verileri belirtebilirsiniz:

• video_title: Zorunlu. Başlık 100 karakteri aşmamalı ve geçersiz karakterler (açılı parantezler < veya >) içermemelidir. Yalnızca video yükleme işlemi oluşturulurken ayarlanabilir ve oluşturulduktan sonra değiştirilemez.
• video_description: İsteğe bağlı. Açıklama 5.000 karakteri aşmamalı ve geçersiz karakterler (açılı parantezler < veya >) içermemelidir. Yalnızca video yükleme işlemi oluşturulurken ayarlanabilir ve oluşturulduktan sonra değiştirilemez.

Her iki alan da oluşturulduktan sonra değiştirilemez. Bir UpdateYouTubeVideoUpload isteğinin güncelleme maskesine video_title veya video_description eklemek FieldError.IMMUTABLE_FIELD hatasıyla başarısız olur.

YouTube başlık ve açıklama biçimlendirmesi ve geçersiz karakterler hakkında daha fazla bilgi için YouTube Yardım Merkezi'ne bakın.

Yapay zekayla üretilmiş içerik açıklaması

26. sürümden itibaren, AB Yapay Zeka Yasası gibi düzenlemeler uyarınca reklamverenler, yüklenen video içeriğinin yapay zekayla üretilmiş veya sentetik medya içerip içermediğini açıklayabilir.

YouTubeVideoUpload içindeki video_content_metadata alanı, VideoContentMetadata değerini içerir. İç içe yerleştirilmiş generative_content_disclosure alanını YouTubeVideoUploadGenerativeContentDisclosure enum değerini kullanarak ayarlayın:

Değer	Açıklama
NON_GENERATIVE_CONTENT	Reklamveren, videonun yapay zeka tarafından üretilmediğini beyan etti.
GENERATIVE_CONTENT	Reklamveren, videonun yapay zekayla üretildiğini belirtti.

Not: video_content_metadata yalnızca giriş amaçlıdır ve yalnızca YouTube videosu yükleme işlemi oluşturulurken ayarlanabilir. Oluşturulduktan sonra değiştirilemez.

Video yükleme

Video yüklemek için CreateYouTubeVideoUpload yöntemine çok parçalı bir istek göndermeniz gerekir. İstek, hem yüklemeyle ilgili meta verileri hem de video dosyasını içerir.

1. Yükleme işlemini başlatma

Aşağıdaki alanları içeren bir CreateYouTubeVideoUploadRequest oluşturun:

Alan	Gereksinim	Açıklama ve kısıtlamalar
customer_id	Zorunlu	10 haneli Google Ads müşteri kimliği (tire olmadan).
you_tube_video_upload.video_title	Zorunlu (INPUT_ONLY, IMMUTABLE)	YouTube'a yüklenen videonun başlığı (en fazla 100 karakter; < veya > içeremez).
you_tube_video_upload.video_description	İsteğe bağlı (INPUT_ONLY, IMMUTABLE)	YouTube'daki videonun açıklaması (en fazla 5.000 karakter; < veya > içeremez).
you_tube_video_upload.channel_id	İsteğe bağlı (IMMUTABLE)	Reklamverene ait marka kanalının 24 karakterden oluşan hedef YouTube kanal kimliği (UC ile başlar). Atlanırsa Google tarafından yönetilen bir kanala yüklenir.
you_tube_video_upload.video_privacy	İsteğe bağlı (marka kanallarında değiştirilebilir)	YouTubeVideoPrivacy ayarı (UNLISTED varsayılan veya reklamverene ait marka kanalları için PUBLIC).
you_tube_video_upload.video_content_metadata	İsteğe bağlı (INPUT_ONLY, IMMUTABLE)	26. sürümden itibaren kullanılabilir: VideoContentMetadata, generative_content_disclosure bir YouTubeVideoUploadGenerativeContentDisclosure değerine (NON_GENERATIVE_CONTENT veya GENERATIVE_CONTENT) ayarlanmış.

İstemci kitaplığı kullanıyorsanız video dosyanızı ileterek CreateYouTubeVideoUpload yöntemini çağırın. Video yükleme işlemi dahili olarak gerçekleştirilir.

Java

String videoUploadResourceName;
try (YouTubeVideoUploadServiceClient youTubeVideoUploadServiceClient =
    googleAdsClient.getLatestVersion().createYouTubeVideoUploadServiceClient()) {
  YouTubeVideoUpload youTubeVideoUpload =
      YouTubeVideoUpload.newBuilder()
          .setVideoTitle("Test Video")
          .setVideoDescription("Test Video Description")
          .setVideoPrivacy(YouTubeVideoPrivacy.UNLISTED)
          .build();

  CreateYouTubeVideoUploadRequest createUploadRequest =
      CreateYouTubeVideoUploadRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .setYouTubeVideoUpload(youTubeVideoUpload)
          .build();

  CreateYouTubeVideoUploadResponse response =
      youTubeVideoUploadServiceClient.createYouTubeVideoUpload(
          createUploadRequest, () -> new FileInputStream(videoFile), null);

  videoUploadResourceName = response.getResourceName();
  System.out.printf("Created YouTube video upload: %s%n", videoUploadResourceName);
}
UploadVideo.java
      

C#

YouTubeVideoUploadServiceClient ytService = client.GetService(
    Services.V26.YouTubeVideoUploadService);

CreateYouTubeVideoUploadRequest createUploadRequest =
    new CreateYouTubeVideoUploadRequest()
    {
        CustomerId = customerId.ToString(),
        YouTubeVideoUpload = new YouTubeVideoUpload()
        {
            VideoTitle = "Test Video",
            VideoDescription = "Test Video Description",
            VideoPrivacy = YouTubeVideoPrivacy.Unlisted
        }
    };

string videoUploadResourceName;
using (FileStream stream = File.OpenRead(videoFilePath))
{
    ResumableUploadSession<CreateYouTubeVideoUploadRequest, CreateYouTubeVideoUploadResponse> session =
        ytService.CreateYouTubeVideoUpload();
    CreateYouTubeVideoUploadResponse response =
        session.BeginUploadAsync(createUploadRequest, stream).Result;

    videoUploadResourceName = response.ResourceName;
    Console.WriteLine($"Created YouTube video upload: {videoUploadResourceName}");
}
UploadVideo.cs
      

PHP

$youTubeVideoUploadServiceClient = $googleAdsClient->getYouTubeVideoUploadServiceClient();

$youTubeVideoUpload = new YouTubeVideoUpload([
    'video_title' => 'Test Video',
    'video_description' => 'Test Video Description',
    'video_privacy' => YouTubeVideoPrivacy::UNLISTED
]);

$createYouTubeVideoUploadRequest = CreateYouTubeVideoUploadRequest::build(
    $customerId,
    $youTubeVideoUpload
);

/** @var ResumableUpload $resumableUpload */
$resumableUpload = $youTubeVideoUploadServiceClient->createYouTubeVideoUpload(
    $createYouTubeVideoUploadRequest
);

$stream = Utils::streamFor(fopen($videoFilePath, 'rb'));
/** @var CreateYouTubeVideoUploadResponse $response */
$response = $resumableUpload->startUpload($stream);

$videoUploadResourceName = $response->getResourceName();
printf("Created YouTube video upload: '%s'%s", $videoUploadResourceName, PHP_EOL);
UploadVideo.php
      

Python

yt_service: YouTubeVideoUploadServiceClient = client.get_service(
    "YouTubeVideoUploadService"
)

create_upload_request: CreateYouTubeVideoUploadRequest = (
    youtube_video_upload_service.CreateYouTubeVideoUploadRequest()
)
create_upload_request.customer_id = customer_id
create_upload_request.you_tube_video_upload.video_title = "Test Video"
create_upload_request.you_tube_video_upload.video_description = (
    "Test Video Description"
)
create_upload_request.you_tube_video_upload.video_privacy = (
    client.enums.YouTubeVideoPrivacyEnum.UNLISTED
)

video_upload_resource_name: str
with open(video_file_path, "rb") as stream:
    response: CreateYouTubeVideoUploadResponse = (
        yt_service.create_you_tube_video_upload(
            stream=stream,
            request=create_upload_request,
            retry=None,
        )
    )
    video_upload_resource_name = response.resource_name
    print(f"Created YouTube video upload: {video_upload_resource_name}")
upload_video.py
      

Ruby

video_upload = client.resource.you_tube_video_upload do |v|
  v.video_title = "Test Video"
  v.video_description = "Test Video Description"
  v.video_privacy = :UNLISTED
end

upload = client.service.you_tube_video_upload.create_you_tube_video_upload(
  customer_id: customer_id,
  you_tube_video_upload: video_upload,
)

video_upload_resource_name = nil
File.open(video_file_path, "rb") do |stream|
  response = upload.start(
    stream: stream,
    content_type: "application/octet-stream",
  )
  video_upload_resource_name = response.resource_name
  puts "Created YouTube video upload: #{video_upload_resource_name}"
end
upload_video.rb
      

Perl

This example is not yet available in Perl; you can take a look at the other languages.
    

curl

# 
# Use the --i curl parameter to capture response headers in the $RESPONSE
# variable.
FILE_SIZE=$(wc -c < "${VIDEO_FILE_NAME}" | tr -d '\r')
RESPONSE=$(curl -i -f -v -s --request POST \
"https://googleads.googleapis.com/resumable/upload/v${API_VERSION}/customers/${CUSTOMER_ID}/youTubeVideoUploads:create" \
--header "Content-Type: application/json" \
--header "login-customer-id: ${MANAGER_CUSTOMER_ID}" \
--header "Authorization: Bearer ${OAUTH2_ACCESS_TOKEN}" \
--header "X-Goog-Upload-Protocol: resumable" \
--header "X-Goog-Upload-Command: start" \
--header "X-Goog-Upload-Header-Content-Length: ${FILE_SIZE}" \
--data @- <<EOF
{
  "customer_id": "${CUSTOMER_ID}",
  "you_tube_video_upload": {
    "video_title": "${VIDEO_TITLE}",
    "video_description": "${VIDEO_DESCRIPTION}",
    "video_privacy": "UNLISTED"
  }
}
EOF
)

# Extract the value of the "x-goog-upload-url" header from the HTTP response.
UPLOAD_URL=$(echo "${RESPONSE}" \
  | grep -i '^x-goog-upload-url' \
  | awk '{print $2}' \
  | tr -d '\r')
CHUNK_SIZE=$(echo "${RESPONSE}" \
  | grep -i '^x-goog-upload-chunk-granularity' \
  | awk '{print $2}' \
  | tr -d '\r')
upload_video.sh
      

REST kullanıyorsanız video yükleme işlemini nasıl yöneteceğiniz aşağıdaki bölümde açıklanmıştır.

2. Videoyu yükleyin.

REST ile yükleme yaparken CreateYouTubeVideoUpload, iki adımlı bir devam ettirilebilir yükleme protokolü kullanır:

1. Yükleme oturumunu başlatın: x-goog-upload-command: start (ve isteğe bağlı olarak dosya boyutunu bildirmek için x-goog-upload-header-content-length) ile CreateYouTubeVideoUpload yükleme uç noktasına (/upload/v26/customers/{customer_id}/youTubeVideoUploads:create) ilk POST isteğini gönderin. Yanıt, yükleme oturumu URL'sini x-goog-upload-url HTTP yanıt başlığında ve beklenen parça boyutu gibi meta verilerle birlikte döndürür.
2. Video baytlarını aktarma ve sonlandırma: İkili video yükünü x-goog-upload-command: upload, finalize ile x-goog-upload-url uç noktasına gönderin. Yükleme tamamlandığında yanıt, oluşturulan resource_name (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}) değerini döndürür.

Video yükleme protokolünde kullanılan HTTP başlıklarının tam açıklaması için aşağıdaki kod örneğine bakın:

# Take the first ${CHUNK_SIZE} bytes of the video file and upload them.
head -c ${CHUNK_SIZE} ${VIDEO_FILE_NAME} | curl -i -v -X PUT "${UPLOAD_URL}" \
--header "Authorization: Bearer ${OAUTH2_ACCESS_TOKEN}" \
--header "X-Goog-Upload-Offset: 0" \
--header "X-Goog-Upload-Command: upload" \
--header "Content-Length: ${CHUNK_SIZE}" \
--data-binary @-

# Query the status of the upload.
QUERY_RESPONSE=$(curl -i -s -X POST "${UPLOAD_URL}" \
--header "Authorization: Bearer ${OAUTH2_ACCESS_TOKEN}" \
--header "X-Goog-Upload-Command: query")

# Extract the value of the "x-goog-upload-size-received" header from the HTTP
# response.
UPLOADED_BYTES=$(echo "${QUERY_RESPONSE}" \
  | grep -i '^x-goog-upload-size-received' \
  | awk '{print $2}' \
  | tr -d '\r')

echo "Uploaded ${UPLOADED_BYTES} bytes."

REMAINING_BYTES=$((FILE_SIZE - UPLOADED_BYTES))
echo "${REMAINING_BYTES} bytes remaining to upload."

FINALIZE_RESPONSE=$(tail -c ${REMAINING_BYTES} ${VIDEO_FILE_NAME} | curl -v -X PUT "${UPLOAD_URL}" \
--header "Authorization: Bearer ${OAUTH2_ACCESS_TOKEN}" \
--header "X-Goog-Upload-Offset: ${UPLOADED_BYTES}" \
--header "X-Goog-Upload-Command: upload, finalize" \
--data-binary @-)
UPLOADED_VIDEO_RESOURCE_NAME=$(echo $FINALIZE_RESPONSE | jq -r '.resourceName')
upload_video.sh
      

3. Video yükleme durumunu alma

Video yükleme işlemini başlattıktan sonra, state = 'PROCESSED' olana kadar GAQL ile you_tube_video_upload kaynağının seçilebilir alanlarını (resource_name, video_upload_id, channel_id, video_id, state ve video_privacy) sorgulayarak işleme durumunu kontrol edin (INPUT_ONLY alanları GAQL'de seçilemez):

Java

// Retrieve the metadata of the newly uploaded video.
String query =
    String.format(
        "SELECT "
            + "you_tube_video_upload.resource_name, "
            + "you_tube_video_upload.video_id, "
            + "you_tube_video_upload.state "
            + "FROM you_tube_video_upload "
            + "WHERE you_tube_video_upload.resource_name = '%s'",
        videoUploadResourceName);

try (GoogleAdsServiceClient googleAdsServiceClient =
    googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
  SearchGoogleAdsStreamRequest request =
      SearchGoogleAdsStreamRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .setQuery(query)
          .build();

  ServerStream<SearchGoogleAdsStreamResponse> stream =
      googleAdsServiceClient.searchStreamCallable().call(request);

  for (SearchGoogleAdsStreamResponse response : stream) {
    for (GoogleAdsRow googleAdsRow : response.getResultsList()) {
      YouTubeVideoUpload video = googleAdsRow.getYouTubeVideoUpload();
      System.out.printf(
          "Video with ID %s was found in state %s.%n",
          video.getVideoId(), video.getState());
    }
  }
}
UploadVideo.java
      

C#

// Retrieve the metadata of the newly uploaded video.
string query = $@"
    SELECT
      you_tube_video_upload.resource_name,
      you_tube_video_upload.video_id,
      you_tube_video_upload.state
    FROM you_tube_video_upload
    WHERE you_tube_video_upload.resource_name = '{videoUploadResourceName}'";

GoogleAdsServiceClient gaService = client.GetService(
    Services.V26.GoogleAdsService);

gaService.SearchStream(customerId.ToString(), query,
    delegate (SearchGoogleAdsStreamResponse resp)
    {
        foreach (GoogleAdsRow row in resp.Results)
        {
            Console.WriteLine(
                $"Video with ID {row.YouTubeVideoUpload.VideoId} was found in " +
                $"state {row.YouTubeVideoUpload.State}.");
        }
    }
);
UploadVideo.cs
      

PHP

// Retrieve the metadata of the newly uploaded video.
$query = sprintf(
    "SELECT you_tube_video_upload.resource_name, "
    . "you_tube_video_upload.video_id, "
    . "you_tube_video_upload.state "
    . "FROM you_tube_video_upload "
    . "WHERE you_tube_video_upload.resource_name = '%s'",
    $videoUploadResourceName
);

$googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
$stream = $googleAdsServiceClient->searchStream(
    SearchGoogleAdsStreamRequest::build($customerId, $query)
);

foreach ($stream->iterateAllElements() as $googleAdsRow) {
    /** @var GoogleAdsRow $googleAdsRow */
    printf(
        "Video with ID '%s' was found in state '%s'.%s",
        $googleAdsRow->getYouTubeVideoUpload()->getVideoId(),
        YouTubeVideoUploadState::name($googleAdsRow->getYouTubeVideoUpload()->getState()),
        PHP_EOL
    );
}
UploadVideo.php
      

Python

# Retrieve the metadata of the newly uploaded video.
query: str = f"""
    SELECT
      you_tube_video_upload.resource_name,
      you_tube_video_upload.video_id,
      you_tube_video_upload.state
    FROM you_tube_video_upload
    WHERE you_tube_video_upload.resource_name = '{video_upload_resource_name}'"""

ga_service: GoogleAdsServiceClient = client.get_service("GoogleAdsService")
stream: Iterator[SearchGoogleAdsStreamResponse] = ga_service.search_stream(
    customer_id=customer_id, query=query
)

for row in itertools.chain.from_iterable(batch.results for batch in stream):
    video = row.you_tube_video_upload
    print(
        f"Video with ID {row.you_tube_video_upload.video_id} was found in state {row.you_tube_video_upload.state}."
    )
upload_video.py
      

Ruby

# Retrieve the metadata of the newly uploaded video.
query = <<~EOQ
  SELECT
    you_tube_video_upload.resource_name,
    you_tube_video_upload.video_id,
    you_tube_video_upload.state
  FROM you_tube_video_upload
  WHERE you_tube_video_upload.resource_name = '#{video_upload_resource_name}'
EOQ

responses = client.service.google_ads.search_stream(
  customer_id: customer_id,
  query: query,
)

responses.each do |batch|
  batch.results.each do |row|
    puts "Video with ID #{row.you_tube_video_upload.video_id} was found in " \
      "state #{row.you_tube_video_upload.state}."
  end
end
upload_video.rb
      

Perl

This example is not yet available in Perl; you can take a look at the other languages.
    

curl

curl -i -v -X POST \
"https://qa-prod-googleads.sandbox.googleapis.com/v${API_VERSION}/customers/${CUSTOMER_ID}/googleAds:search" \
--header "Content-Type: application/json" \
  --header "Developer-Token: ${DEVELOPER_TOKEN}" \
  --header "login-customer-id: ${MANAGER_CUSTOMER_ID}" \
  --header "Authorization: Bearer ${OAUTH2_ACCESS_TOKEN}" \
  --data @- <<EOF
{
  "query": "SELECT you_tube_video_upload.resource_name, you_tube_video_upload.video_id, you_tube_video_upload.state FROM you_tube_video_upload WHERE you_tube_video_upload.resource_name = '$UPLOADED_VIDEO_RESOURCE_NAME'"
}
EOF
upload_video.sh
      

Yüklemeleri yönet

Yükleme işlemi tamamlandıktan sonra videoyu video öğesi olarak kullanabilirsiniz.

Yüklenen videoyu kullanma

Bir video PROCESSED durumuna ulaştıktan sonra 11 karakterlik YouTube video kimliğini YouTubeVideoUpload kaynağının video_id alanında bulabilirsiniz.

MutateAssets ile YoutubeVideoAsset oluşturmak için bu video_id kullanın ve elde edilen öğe kaynak adını (customers/{customer_id}/assets/{asset_id}) kampanyalarınıza veya reklamlarınıza bağlayın:

1. AssetService.MutateAssets yöntemine youtube_video_id değerini ileterek YoutubeVideoAsset oluşturun:

   POST https://googleads.googleapis.com/v26/customers/{customer_id}/assets:mutate
   {
     "operations": [
       {
         "create": {
           "name": "Product Launch Video",
           "youtubeVideoAsset": {
             "youtubeVideoId": "dQw4w9WgXcQ"
           }
         }
       }
     ]
   }
   

2. Asset ile AssetGroup veya AdGroupAd arasında bağlantı oluşturma:

   • Maksimum Performans: field_type, YOUTUBE_VIDEO olarak ayarlanmış şekilde AssetGroupAssetService.MutateAssetGroupAssets kullanarak bir AssetGroupAsset oluşturun:

     POST https://googleads.googleapis.com/v26/customers/{customer_id}/assetGroupAssets:mutate
     {
       "operations": [
         {
           "create": {
             "assetGroup": "customers/{customer_id}/assetGroups/{asset_group_id}",
             "asset": "customers/{customer_id}/assets/{asset_id}",
             "fieldType": "YOUTUBE_VIDEO"
           }
         }
       ]
     }
     

   • Talep Yaratma: AdGroupAdService.MutateAdGroupAds çağrılırken bir DemandGenVideoResponsiveAdInfo nesnesinin videos listesinde customers/{customer_id}/assets/{asset_id} referans olarak gösterilir:

     POST https://googleads.googleapis.com/v26/customers/{customer_id}/adGroupAds:mutate
     {
       "operations": [
         {
           "create": {
             "adGroup": "customers/{customer_id}/adGroups/{ad_group_id}",
             "status": "PAUSED",
             "ad": {
               "name": "Demand Gen Video Ad",
               "finalUrls": ["https://www.example.com"],
               "demandGenVideoResponsiveAd": {
                 "videos": [
                   {
                     "asset": "customers/{customer_id}/assets/{asset_id}"
                   }
                 ],
                 "logoImages": [
                   {
                     "asset": "customers/{customer_id}/assets/{logo_asset_id}"
                   }
                 ],
                 "headlines": [
                   {
                     "text": "Example Headline"
                   }
                 ],
                 "longHeadlines": [
                   {
                     "text": "Example Long Headline"
                   }
                 ],
                 "descriptions": [
                   {
                     "text": "Example Description"
                   }
                 ],
                 "businessName": {
                   "text": "Example Business"
                 }
               }
             }
           }
         }
       ]
     }
     

3. GoogleAdsService.SearchStream kullanarak mevcut YOUTUBE_VIDEO öğeleri sorgulama:

   SELECT
     asset.id,
     asset.resource_name,
     asset.name,
     asset.type,
     asset.youtube_video_asset.youtube_video_id,
     asset.youtube_video_asset.youtube_video_title
   FROM asset
   WHERE asset.type = 'YOUTUBE_VIDEO'
     AND asset.youtube_video_asset.youtube_video_id = '{video_id}'
   

Meta veriyi güncelle

Bu API aracılığıyla yüklenen bir videonun gizlilik ayarını, update_mask parametresi "video_privacy" olarak ayarlanmış UpdateYouTubeVideoUpload yöntemini kullanarak güncelleyebilirsiniz. Oluşturulduktan sonra yalnızca video_privacy alanı (reklamverenin sahip olduğu marka kanalına yüklenen videolar için PUBLIC veya UNLISTED) güncellenebilir; video_title, video_description, channel_id ve video_content_metadata değiştirilemez. Güncelleme maskesine video_title veya video_description eklenirse FieldError.IMMUTABLE_FIELD hatası alınır.

Yüklemeleri kaldırma

Google Ads API ile yüklenen videoları silmeniz gerekiyorsa RemoveYouTubeVideoUpload yönteminin resource_names alanına customers/{customer_id}/youTubeVideoUploads/{video_upload_id} kaynak adlarını iletin. Bu işlem, videoyu hem Google Ads öğe kitaplığından hem de YouTube'dan kaldırır.