อัปโหลดวิดีโอ

หมายเหตุ: การอัปโหลดวิดีโอด้วย Google Ads API รองรับเฉพาะไลบรารีของไคลเอ็นต์ .NET, PHP และ Python และโดยใช้ REST สำหรับไลบรารีของไคลเอ็นต์อื่นๆ คุณสามารถอัปโหลดวิดีโอได้โดยตรงโดยใช้ YouTube Data API v3 และสร้าง YoutubeVideoAsset ด้วยรหัสวิดีโอ YouTube ที่ได้

YouTubeVideoUploadService ช่วยให้คุณอัปโหลดวิดีโอไปยัง YouTube ได้โดยตรงผ่าน Google Ads API จากนั้นคุณสามารถใช้วิดีโอเหล่านี้เพื่อสร้างชิ้นงานวิดีโอในประเภทโฆษณาต่างๆ เช่น แคมเปญ Performance Max หรือแคมเปญ Demand Gen

บริการนี้ช่วยปรับปรุงเวิร์กโฟลว์การสร้างโฆษณาวิดีโอโดยจัดการกระบวนการอัปโหลด YouTube เพื่อให้มั่นใจว่าวิดีโอเชื่อมโยงกับบัญชีของคุณอย่างถูกต้อง

แนวคิดสำคัญ

ก่อนเริ่มต้น คุณควรทำความเข้าใจวิธีจัดการการอัปโหลดวิดีโอและสถานะต่างๆ ที่วิดีโออาจมี

เวิร์กโฟลว์ตั้งแต่ต้นจนจบ

การอัปโหลดไฟล์วิดีโอและแสดงในโฆษณาต้องทำตาม 4 ขั้นตอนตามลำดับต่อไปนี้

ขั้นตอน	บริการและวิธีการ	สรุป
1. เริ่มต้นและอัปโหลดไบต์วิดีโอ	CreateYouTubeVideoUpload ใน YouTubeVideoUploadService	อัปโหลดข้อมูลเมตาของวิดีโอและไฟล์ไบนารีเพื่อสร้างทรัพยากร YouTubeVideoUpload (customers/{customer_id}/youTubeVideoUploads/{video_upload_id})
2. สถานะการประมวลผลแบบสำรวจ	SearchStream ใน GoogleAdsService	ค้นหา you_tube_video_upload จนถึง state = 'PROCESSED' และระบบจะป้อน video_id ของ YouTube ที่มีอักขระ 11 ตัว
3. สร้างชิ้นงานวิดีโอที่นำกลับมาใช้ซ้ำได้	MutateAssets ใน AssetService	สร้าง YoutubeVideoAsset (youtube_video_id = video_id) เพื่อรับชื่อทรัพยากรชิ้นงาน (customers/{customer_id}/assets/{asset_id})
4. ลิงก์ชิ้นงานกับแคมเปญหรือโฆษณา	MutateAssetGroupAssets ในวันที่ AssetGroupAssetService หรือ MutateAdGroupAds ในวันที่ AdGroupAdService	ลิงก์ชิ้นงานกับ Performance Max AssetGroupAsset (field_type = YOUTUBE_VIDEO) หรือ Demand Gen DemandGenVideoResponsiveAdInfo (videos[].asset)

การเป็นเจ้าของช่อง

เมื่ออัปโหลดวิดีโอ คุณสามารถระบุช่อง YouTube ปลายทางได้โดยใช้ช่อง channel_id ในทรัพยากร YouTubeVideoUpload ดังนี้

• ช่องที่ผู้ลงโฆษณาเป็นเจ้าของ (แบรนด์): ระบุ channel_id ของช่อง YouTube ที่มีอยู่ซึ่งผู้ลงโฆษณาเป็นเจ้าของ ซึ่งรองรับเฉพาะขั้นตอนการตรวจสอบสิทธิ์ผู้ใช้เท่านั้น และใช้กับบัญชีบริการไม่ได้
• ช่องที่จัดการโดย Google: หากไม่ระบุ channel_id ระบบจะอัปโหลดวิดีโอไปยังช่อง YouTube ที่จัดการโดย Google ซึ่งเชื่อมโยงกับบัญชี Google Ads

สถานะการอัปโหลด

วงจรการอัปโหลดวิดีโอ YouTube จะติดตามโดยช่อง state YouTubeVideoUploadState enum กำหนดสถานะต่อไปนี้

รัฐ	คำอธิบาย
PENDING	กำลังอัปโหลดวิดีโอ
UPLOADED	อัปโหลดวิดีโอเรียบร้อยแล้ว และ YouTube กำลังประมวลผลวิดีโอ
PROCESSED	ระบบประมวลผลวิดีโอเรียบร้อยแล้วและพร้อมใช้งาน
FAILED	การอัปโหลดหรือการประมวลผลไม่สำเร็จและดำเนินการให้เสร็จสมบูรณ์ไม่ได้
REJECTED	วิดีโอถูกปฏิเสธเนื่องจากเหตุผลด้านการตรวจสอบหรือนโยบาย
UNAVAILABLE	สถานะวิดีโอไม่พร้อมใช้งาน วิดีโออาจถูกนำออกจาก YouTube แล้ว

การตั้งค่าความเป็นส่วนตัว

ช่อง video_privacy จะควบคุมผู้ที่ดูวิดีโอที่อัปโหลดได้ YouTubeVideoPrivacy enum รองรับค่าต่อไปนี้

• PUBLIC: วิดีโอพร้อมให้ทุกคนรับชมบน YouTube (อนุญาตให้ใช้กับช่องของแบรนด์เท่านั้น)
• UNLISTED: วิดีโอจะค้นหาไม่ได้ แต่ทุกคนที่มีลิงก์จะดูได้ ซึ่งเป็นค่าเริ่มต้นและเป็นตัวเลือกเดียวสำหรับช่องทางที่ Google จัดการ

ข้อกำหนดเกี่ยวกับชื่อและคำอธิบาย

เมื่อสร้างการอัปโหลดวิดีโอ คุณสามารถระบุข้อมูลเมตาโดยใช้ช่อง video_title และ video_description ในทรัพยากร YouTubeVideoUpload ดังนี้

• video_title: ต้องระบุ ชื่อต้องมีความยาวไม่เกิน 100 อักขระและต้องไม่มีอักขระที่ไม่ถูกต้อง (วงเล็บมุม < หรือ >) โดยจะตั้งค่าได้เมื่อสร้างการอัปโหลดวิดีโอเท่านั้น และจะเปลี่ยนแปลงไม่ได้หลังจากสร้างแล้ว
• video_description: ไม่บังคับ คำอธิบายต้องมีความยาวไม่เกิน 5,000 อักขระและต้องไม่มีอักขระที่ไม่ถูกต้อง (วงเล็บมุม < หรือ >) โดยจะตั้งค่าได้เมื่อสร้างการอัปโหลดวิดีโอเท่านั้นและจะเปลี่ยนแปลงไม่ได้หลังจากสร้างแล้ว

ทั้ง 2 ช่องจะเปลี่ยนแปลงไม่ได้หลังจากสร้างแล้ว การรวม video_title หรือ video_description ไว้ในมาสก์การอัปเดตของคำขอ UpdateYouTubeVideoUpload จะไม่สำเร็จพร้อมข้อผิดพลาด FieldError.IMMUTABLE_FIELD

ดูข้อมูลเพิ่มเติมเกี่ยวกับการจัดรูปแบบชื่อและคำอธิบายของ YouTube รวมถึงอักขระที่ไม่ถูกต้องได้ที่ศูนย์ช่วยเหลือของ YouTube

การเปิดเผยเนื้อหา Generative AI

ตั้งแต่ v26 เป็นต้นไป ภายใต้กฎระเบียบต่างๆ เช่น กฎหมายว่าด้วยเรื่อง AI ของสหภาพยุโรป ผู้ลงโฆษณาสามารถเปิดเผยได้ว่าเนื้อหาวิดีโอที่อัปโหลดมีสื่อที่ AI สร้างขึ้นหรือสื่อสังเคราะห์หรือไม่

ช่อง video_content_metadata ใน YouTubeVideoUpload มี VideoContentMetadata ตั้งค่าฟิลด์ generative_content_disclosure ที่ฝังอยู่โดยใช้ enum YouTubeVideoUploadGenerativeContentDisclosure ดังนี้

ค่า	คำอธิบาย
NON_GENERATIVE_CONTENT	ผู้ลงโฆษณาเปิดเผยว่าวิดีโอไม่ได้สร้างขึ้นโดย AI
GENERATIVE_CONTENT	ผู้ลงโฆษณาเปิดเผยว่าวิดีโอนี้สร้างขึ้นโดย AI

หมายเหตุ: video_content_metadata เป็นอินพุตเท่านั้น และตั้งค่าได้เมื่อสร้างการอัปโหลดวิดีโอ YouTube เท่านั้น ซึ่งจะเปลี่ยนแปลงไม่ได้หลังจากสร้างแล้ว

อัปโหลดวิดีโอ

หากต้องการอัปโหลดวิดีโอ คุณต้องใช้คำขอแบบหลายส่วนกับเมธอด CreateYouTubeVideoUpload คำขอประกอบด้วยทั้งข้อมูลเมตาสำหรับการอัปโหลดและไฟล์วิดีโอ

1. เริ่มการอัปโหลด

สร้าง CreateYouTubeVideoUploadRequest ที่มีช่องต่อไปนี้

ช่อง	ข้อกำหนด	คำอธิบายและข้อจำกัด
customer_id	ต้องระบุ	รหัสลูกค้า Google Ads 10 หลัก (ไม่มีขีดกลาง)
you_tube_video_upload.video_title	ต้องระบุ (INPUT_ONLY, IMMUTABLE)	ชื่อวิดีโอที่อัปโหลดบน YouTube (ไม่เกิน 100 อักขระ และต้องไม่มี < หรือ >)
you_tube_video_upload.video_description	ไม่บังคับ (INPUT_ONLY, IMMUTABLE)	คำอธิบายวิดีโอบน YouTube (สูงสุด 5,000 อักขระ และต้องไม่มี < หรือ >)
you_tube_video_upload.channel_id	ไม่บังคับ (IMMUTABLE)	รหัสช่อง YouTube ปลายทางจำนวน 24 อักขระ (ขึ้นต้นด้วย UC) สำหรับช่องของแบรนด์ที่ผู้ลงโฆษณาเป็นเจ้าของ หากไม่ระบุ ระบบจะอัปโหลดไปยังช่องที่จัดการโดย Google
you_tube_video_upload.video_privacy	ไม่บังคับ (เปลี่ยนแปลงได้ในช่องของแบรนด์)	การตั้งค่า YouTubeVideoPrivacy (UNLISTED เป็นค่าเริ่มต้น หรือ PUBLIC สำหรับช่องของแบรนด์ที่ผู้ลงโฆษณาเป็นเจ้าของ)
you_tube_video_upload.video_content_metadata	ไม่บังคับ (INPUT_ONLY, IMMUTABLE)	พร้อมใช้งานตั้งแต่เวอร์ชัน 26: VideoContentMetadata โดยตั้งค่า generative_content_disclosure เป็นค่า YouTubeVideoUploadGenerativeContentDisclosure (NON_GENERATIVE_CONTENT หรือ GENERATIVE_CONTENT)

หากคุณใช้ไลบรารีของไคลเอ็นต์ ให้เรียกใช้เมธอด CreateYouTubeVideoUpload โดยส่งไฟล์วิดีโอ แล้วระบบจะจัดการการอัปโหลดวิดีโอภายใน

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 ส่วนต่อไปนี้จะอธิบายวิธีจัดการการอัปโหลดวิดีโอ

2. อัปโหลดวิดีโอ

เมื่ออัปโหลดด้วย REST CreateYouTubeVideoUpload จะใช้โปรโตคอลการอัปโหลดที่ดำเนินการต่อได้แบบ 2 ขั้นตอน ดังนี้

1. เริ่มเซสชันการอัปโหลด: ส่งคำขอ POST เริ่มต้นไปยังปลายทางการอัปโหลด CreateYouTubeVideoUpload (/upload/v26/customers/{customer_id}/youTubeVideoUploads:create) พร้อมกับ x-goog-upload-command: start (และ x-goog-upload-header-content-length เพื่อประกาศขนาดไฟล์ (ไม่บังคับ)) การตอบกลับจะแสดง URL ของเซสชันการอัปโหลดในส่วนหัวการตอบกลับ HTTP x-goog-upload-url พร้อมกับข้อมูลเมตา เช่น ขนาดกลุ่มที่คาดไว้
2. สตรีมและสรุปไบต์วิดีโอ: ส่งเพย์โหลดวิดีโอไบนารีไปยังปลายทาง x-goog-upload-url ด้วย x-goog-upload-command: upload, finalize เมื่ออัปโหลดเสร็จแล้ว การตอบกลับจะแสดง resource_name (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}) ที่สร้างขึ้น

ดูคำอธิบายแบบเต็มของส่วนหัว HTTP ที่ใช้ในโปรโตคอลการอัปโหลดวิดีโอได้จากตัวอย่างโค้ดต่อไปนี้

# 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. ดึงข้อมูลสถานะการอัปโหลดวิดีโอ

หลังจากเริ่มอัปโหลดวิดีโอ ให้ตรวจสอบสถานะการประมวลผลโดยค้นหาช่องที่เลือกได้ของทรัพยากร you_tube_video_upload (resource_name, video_upload_id, channel_id, video_id, state และ video_privacy) ด้วย GAQL จนกว่าจะถึง state = 'PROCESSED' (ไม่สามารถเลือกช่อง INPUT_ONLY ใน 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
      

จัดการการอัปโหลด

หลังจากอัปโหลดวิดีโอเสร็จแล้ว คุณจะใช้วิดีโอดังกล่าวเป็นชิ้นงานวิดีโอได้

ใช้วิดีโอที่อัปโหลด

หลังจากวิดีโอถึงสถานะ PROCESSED คุณจะเห็นรหัสวิดีโอ YouTube ที่มีอักขระ 11 ตัวในช่อง video_id ของทรัพยากร YouTubeVideoUpload

ใช้ video_id นี้เพื่อสร้าง YoutubeVideoAsset ด้วย MutateAssets และลิงก์ชื่อทรัพยากรชิ้นงานที่ได้ (customers/{customer_id}/assets/{asset_id}) กับแคมเปญหรือโฆษณา

1. สร้าง YoutubeVideoAsset โดยส่ง youtube_video_id ไปยัง AssetService.MutateAssets:

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

2. ลิงก์ Asset กับ AssetGroup หรือ AdGroupAd

   • Performance Max: สร้าง AssetGroupAsset โดยใช้ AssetGroupAssetService.MutateAssetGroupAssets ที่ตั้งค่า field_type เป็น 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"
           }
         }
       ]
     }
     

   • Demand Gen: อ้างอิง customers/{customer_id}/assets/{asset_id} ในรายการ videos ของออบเจ็กต์ DemandGenVideoResponsiveAdInfo เมื่อเรียกใช้ 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. ค้นหาชิ้นงาน YOUTUBE_VIDEO ที่มีอยู่โดยใช้ 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}'
   

อัปเดตข้อมูลเมตา

คุณสามารถอัปเดตการตั้งค่าความเป็นส่วนตัวของวิดีโอที่อัปโหลดผ่าน API นี้ได้โดยใช้เมธอด UpdateYouTubeVideoUpload โดยตั้งค่า update_mask เป็น "video_privacy" คุณสามารถอัปเดตได้เฉพาะช่อง video_privacy (PUBLIC หรือ UNLISTED สำหรับวิดีโอที่อัปโหลดไปยังช่องของแบรนด์ที่ผู้ลงโฆษณาเป็นเจ้าของ) หลังจากสร้างแล้ว ส่วน video_title, video_description, channel_id และ video_content_metadata จะเปลี่ยนแปลงไม่ได้ การรวม video_title หรือ video_description ในมาสก์การอัปเดตจะดำเนินการไม่สำเร็จและแสดงข้อผิดพลาด FieldError.IMMUTABLE_FIELD

นำการอัปโหลดออก

หากต้องการลบวิดีโอที่อัปโหลดด้วย Google Ads API ให้ส่ง customers/{customer_id}/youTubeVideoUploads/{video_upload_id} ชื่อทรัพยากร ในช่อง resource_names ของ เมธอด RemoveYouTubeVideoUpload การดำเนินการนี้จะนำวิดีโอออกจากทั้งคลังชิ้นงานของ Google Ads และ YouTube