Tải lên video

Lưu ý: API Google Ads chỉ hỗ trợ việc tải video lên bằng các thư viện ứng dụng .NET, PHP, và Python, cũng như bằng cách sử dụng REST. Đối với các thư viện ứng dụng khác, bạn có thể tải video lên trực tiếp bằng YouTube Data API v3 và tạo YoutubeVideoAsset bằng mã video YouTube thu được.

YouTubeVideoUploadService cho phép bạn tải video trực tiếp lên YouTube thông qua Google Ads API. Sau đó, bạn có thể sử dụng những video này để tạo thành phần video trong nhiều loại quảng cáo, chẳng hạn như chiến dịch Tối đa hoá hiệu suất hoặc chiến dịch Tạo nhu cầu.

Dịch vụ này giúp đơn giản hoá quy trình tạo quảng cáo dạng video bằng cách xử lý quy trình tải lên YouTube, đảm bảo rằng các video được liên kết chính xác với tài khoản của bạn.

Khái niệm chính

Trước khi bắt đầu, bạn cần hiểu cách quản lý nội dung tải lên video và các trạng thái mà nội dung đó có thể trải qua.

Quy trình công việc toàn diện

Để tải tệp video lên và phân phát tệp đó trong quảng cáo, bạn cần thực hiện 4 bước theo trình tự:

Bước	Dịch vụ và phương thức	Tóm tắt
1. Bắt đầu và tải byte video lên	CreateYouTubeVideoUpload trên YouTubeVideoUploadService	Tải siêu dữ liệu video và tệp nhị phân lên để tạo tài nguyên YouTubeVideoUpload (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}).
2. Trạng thái xử lý thăm dò ý kiến	SearchStream trên GoogleAdsService	Truy vấn you_tube_video_upload cho đến khi state = 'PROCESSED' và mã video_id gồm 11 ký tự trên YouTube được điền sẵn.
3. Tạo thành phần video có thể dùng lại	MutateAssets trên AssetService	Tạo YoutubeVideoAsset (youtube_video_id = video_id) để nhận tên tài nguyên thành phần (customers/{customer_id}/assets/{asset_id}).
4. Liên kết thành phần với chiến dịch hoặc quảng cáo	MutateAssetGroupAssets trên AssetGroupAssetService hoặc MutateAdGroupAds trên AdGroupAdService	Liên kết thành phần với AssetGroupAsset Tối đa hoá hiệu suất (field_type = YOUTUBE_VIDEO) hoặc DemandGenVideoResponsiveAdInfo Tạo nhu cầu (videos[].asset).

Quyền sở hữu kênh

Khi tải video lên, bạn có thể chỉ định kênh YouTube đích bằng cách sử dụng trường channel_id trong tài nguyên YouTubeVideoUpload:

• Kênh do nhà quảng cáo sở hữu (kênh thương hiệu): Cung cấp channel_id của một kênh YouTube hiện có do nhà quảng cáo sở hữu. Tính năng này chỉ được hỗ trợ trong quy trình xác thực người dùng; bạn không thể sử dụng tính năng này với tài khoản dịch vụ.
• Kênh do Google quản lý: Nếu bạn bỏ qua channel_id, video sẽ được tải lên một kênh YouTube do Google quản lý được liên kết với tài khoản Google Ads.

Trạng thái tải lên

Vòng đời của nội dung tải lên video trên YouTube được theo dõi bằng trường state. Enum YouTubeVideoUploadState xác định các trạng thái sau:

Tiểu bang	Mô tả
PENDING	Video đang được tải lên.
UPLOADED	Video đã được tải lên thành công và đang được YouTube xử lý.
PROCESSED	Video đã được xử lý thành công và sẵn sàng sử dụng.
FAILED	Không tải lên hoặc xử lý được và không thể hoàn tất.
REJECTED	Video đã bị từ chối do lý do xác thực hoặc chính sách.
UNAVAILABLE	Không có trạng thái video; video có thể đã bị xoá khỏi YouTube.

Chế độ cài đặt quyền riêng tư

Trường video_privacy kiểm soát những người có thể xem video đã tải lên. Enum YouTubeVideoPrivacy hỗ trợ:

• PUBLIC: Bất kỳ ai trên YouTube cũng có thể xem video. (Chỉ được phép dùng cho kênh thương hiệu).
• UNLISTED: Video không thể tìm kiếm được nhưng bất kỳ ai có đường liên kết đều có thể xem video. Đây là lựa chọn mặc định và duy nhất cho các kênh do Google quản lý.

Công bố nội dung do AI tạo

Kể từ phiên bản 26, theo các quy định như Đạo luật về AI của Liên minh Châu Âu, nhà quảng cáo có thể công bố liệu nội dung video đã tải lên có chứa nội dung do AI tạo hoặc nội dung tổng hợp hay không.

Trường video_content_metadata trong YouTubeVideoUpload chứa VideoContentMetadata. Đặt trường generative_content_disclosure lồng nhau bằng cách sử dụng YouTubeVideoUploadGenerativeContentDisclosure enum:

Giá trị	Mô tả
NON_GENERATIVE_CONTENT	Nhà quảng cáo đã công bố video là nội dung không do AI tạo.
GENERATIVE_CONTENT	Nhà quảng cáo đã công bố video là nội dung do AI tạo.

Lưu ý: video_content_metadata chỉ dành cho dữ liệu đầu vào và bạn chỉ có thể đặt trường này khi tạo nội dung tải lên video trên YouTube. Bạn không thể thay đổi trường này sau khi tạo.

Tải video lên

Để tải video lên, bạn phải sử dụng yêu cầu nhiều phần cho phương thức CreateYouTubeVideoUpload. Yêu cầu này chứa cả siêu dữ liệu cho nội dung tải lên và chính tệp video.

1. Bắt đầu tải lên

Tạo CreateYouTubeVideoUploadRequest với các trường sau:

Trường	Yêu cầu	Mô tả và các hạn chế
customer_id	Bắt buộc	Mã khách hàng Google Ads gồm 10 chữ số (không có dấu gạch nối).
you_tube_video_upload.video_title	Bắt buộc (INPUT_ONLY, IMMUTABLE)	Tiêu đề của video đã tải lên trên YouTube (tối đa 100 ký tự; không được chứa < hoặc >).
you_tube_video_upload.video_description	Không bắt buộc (INPUT_ONLY, IMMUTABLE)	Nội dung mô tả video trên YouTube (tối đa 5.000 ký tự; không được chứa < hoặc >).
you_tube_video_upload.channel_id	Không bắt buộc (IMMUTABLE)	Mã nhận dạng kênh YouTube đích gồm 24 ký tự (bắt đầu bằng UC) cho kênh thương hiệu do nhà quảng cáo sở hữu. Nếu bạn bỏ qua trường này, nội dung sẽ được tải lên một kênh do Google quản lý.
you_tube_video_upload.video_privacy	Không bắt buộc (có thể thay đổi trên kênh thương hiệu)	YouTubeVideoPrivacy chế độ cài đặt (UNLISTED mặc định hoặc PUBLIC cho kênh thương hiệu do nhà quảng cáo sở hữu).
you_tube_video_upload.video_content_metadata	Không bắt buộc (INPUT_ONLY, IMMUTABLE)	Có từ phiên bản 26: VideoContentMetadata có generative_content_disclosure được đặt thành giá trị YouTubeVideoUploadGenerativeContentDisclosure (NON_GENERATIVE_CONTENT hoặc GENERATIVE_CONTENT).

Nếu bạn đang sử dụng thư viện ứng dụng, hãy gọi CreateYouTubeVideoUpload phương thức, chuyển tệp video của bạn và nội dung tải lên video sẽ được xử lý nội bộ.

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
      

Nếu bạn đang sử dụng REST, phần sau đây sẽ mô tả cách quản lý nội dung tải lên video.

2. Tải video lên

Khi tải lên bằng REST, CreateYouTubeVideoUpload sử dụng giao thức tải lên có thể tiếp tục gồm 2 bước resumable upload protocol:

1. Bắt đầu phiên tải lên: Gửi yêu cầu POST ban đầu đến điểm cuối tải lên CreateYouTubeVideoUpload (/upload/v26/customers/{customer_id}/youTubeVideoUploads:create) với x-goog-upload-command: start (và tuỳ ý x-goog-upload-header-content-length để khai báo kích thước tệp). Phản hồi sẽ trả về URL phiên tải lên trong tiêu đề phản hồi HTTP x-goog-upload-url, cùng với siêu dữ liệu như kích thước khối dự kiến.
2. Phát trực tuyến và hoàn tất byte video: Gửi tải trọng video nhị phân đến điểm cuối x-goog-upload-url với x-goog-upload-command: upload, finalize. Khi quá trình tải lên hoàn tất, phản hồi sẽ trả về resource_name đã tạo (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}).

Để biết nội dung mô tả đầy đủ về các tiêu đề HTTP được sử dụng trong giao thức tải lên video, hãy tham khảo ví dụ về mã sau:

# 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. Truy xuất trạng thái tải lên video

Sau khi bắt đầu tải video lên, hãy thăm dò trạng thái xử lý của video đó bằng cách truy vấn các trường có thể chọn của tài nguyên you_tube_video_upload (resource_name, video_upload_id, channel_id, video_id, state, và video_privacy) bằng GAQL cho đến khi state = 'PROCESSED' (bạn không thể chọn các trường INPUT_ONLY trong GAQL):

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
      

Quản lý mục tải lên

Sau khi hoàn tất quá trình tải video lên, bạn có thể sử dụng video đó làm thành phần video.

Sử dụng video đã tải lên

Sau khi video đạt đến trạng thái PROCESSED, bạn có thể tìm thấy mã video YouTube gồm 11 ký tự trong trường video_id của tài nguyên YouTubeVideoUpload.

Sử dụng video_id này để tạo YoutubeVideoAsset bằng MutateAssets và liên kết tên tài nguyên thành phần thu được (customers/{customer_id}/assets/{asset_id}) với chiến dịch hoặc quảng cáo của bạn:

1. Tạo YoutubeVideoAsset bằng cách chuyển youtube_video_id đến AssetService.MutateAssets:

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

2. Liên kết Asset với AssetGroup hoặc AdGroupAd:

   • Tối đa hoá hiệu suất: Tạo AssetGroupAsset bằng AssetGroupAssetService.MutateAssetGroupAssets với field_type được đặt thành YOUTUBE_VIDEO:

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

   • Tạo nhu cầu: Tham chiếu customers/{customer_id}/assets/{asset_id} trong danh sách videos của đối tượng DemandGenVideoResponsiveAdInfo khi gọi AdGroupAdService.MutateAdGroupAds:

     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. Truy vấn các thành phần YOUTUBE_VIDEO hiện có bằng GoogleAdsService.SearchStream:

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

Cập nhật siêu dữ liệu

Bạn có thể cập nhật chế độ cài đặt quyền riêng tư của video đã tải lên thông qua API này bằng phương thức UpdateYouTubeVideoUpload với update_mask được đặt thành "video_privacy". Sau khi tạo, bạn chỉ có thể cập nhật trường video_privacy (PUBLIC hoặc UNLISTED cho video đã tải lên kênh thương hiệu do nhà quảng cáo sở hữu); video_title, video_description, channel_id và video_content_metadata là không thể thay đổi.

Xoá nội dung tải lên

Nếu bạn cần xoá video đã tải lên bằng Google Ads API, hãy chuyển tên tài nguyên customers/{customer_id}/youTubeVideoUploads/{video_upload_id} của video đó vào trường resource_names của phương thức RemoveYouTubeVideoUpload. Thao tác này sẽ xoá video khỏi cả thư viện thành phần trên Google Ads và YouTube.