Prześlij filmy

Uwaga: przesyłanie filmów za pomocą interfejsu Google Ads API jest obsługiwane tylko w przypadku bibliotek klienta .NET, PHP, i Python oraz przy użyciu REST. W przypadku innych bibliotek klienta możesz przesyłać filmy bezpośrednio za pomocą interfejsu YouTube Data API w wersji 3 i tworzyć element YoutubeVideoAsset z uzyskanym identyfikatorem filmu na YouTube.

YouTubeVideoUploadService umożliwia przesyłanie filmów bezpośrednio do YouTube za pomocą interfejsu Google Ads API. Te filmy można następnie wykorzystać do tworzenia komponentów wideo w różnych typach reklam, np. w kampaniach Performance Max lub kampaniach generujących popyt.

Ta usługa upraszcza proces tworzenia reklam wideo, ponieważ obsługuje proces przesyłania do YouTube i zapewnia prawidłowe powiązanie filmów z Twoim kontem.

Kluczowe pojęcia

Zanim zaczniesz, musisz zrozumieć, jak zarządza się przesyłaniem filmów i jakie stany mogą one przyjmować.

Kompletny przepływ pracy

Przesłanie pliku wideo i wyświetlenie go w reklamie wymaga wykonania 4 kolejnych czynności:

Krok	Usługa i metoda	Podsumowanie
1. Inicjowanie i przesyłanie bajtów wideo	CreateYouTubeVideoUpload w YouTubeVideoUploadService	Prześlij metadane filmu i plik binarny, aby utworzyć zasób YouTubeVideoUpload (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}).
2. Sprawdzanie stanu przetwarzania	SearchStream w GoogleAdsService	Wysyłaj zapytania do you_tube_video_upload, dopóki state = 'PROCESSED' i nie zostanie wypełniony 11-znakowy identyfikator video_id w YouTube.
3. Tworzenie komponentu wideo wielokrotnego użytku	MutateAssets w AssetService	Utwórz YoutubeVideoAsset (youtube_video_id = video_id), aby uzyskać nazwę zasobu komponentu (customers/{customer_id}/assets/{asset_id}).
4. Łączenie komponentu z kampaniami lub reklamami	MutateAssetGroupAssets w AssetGroupAssetService lub MutateAdGroupAds w AdGroupAdService	Połącz zasób z elementem Performance Max AssetGroupAsset (field_type = YOUTUBE_VIDEO) lub z kampanią generującą popyt DemandGenVideoResponsiveAdInfo (videos[].asset).

Własność kanału

Podczas przesyłania filmu możesz określić docelowy kanał w YouTube za pomocą pola channel_id w zasobie YouTubeVideoUpload:

• Kanał należący do reklamodawcy (marki): podaj channel_id istniejącego kanału w YouTube należącego do reklamodawcy. Jest to obsługiwane tylko w przypadku przepływu uwierzytelniania użytkownika; nie można go używać z kontami usługi.
• Kanał zarządzany przez Google: jeśli pominiesz channel_id, film zostanie przesłany na kanał w YouTube zarządzany przez Google, który jest powiązany z kontem Google Ads.

Stany przesyłania

Cykl życia przesyłania filmu na YouTube jest śledzony przez pole state. Wyliczenie YouTubeVideoUploadState definiuje te stany:

Stan	Opis
PENDING	Trwa przesyłanie filmu.
UPLOADED	Film został przesłany i jest przetwarzany przez YouTube.
PROCESSED	Film został przetworzony i jest gotowy do użycia.
FAILED	Przesyłanie lub przetwarzanie nie powiodło się i nie można go ukończyć.
REJECTED	Film został odrzucony z powodu weryfikacji lub naruszenia zasad.
UNAVAILABLE	Stan filmu jest niedostępny. Film mógł zostać usunięty z YouTube.

Ustawienia prywatności

Pole video_privacy określa, kto może zobaczyć przesłany film. Wyliczenie YouTubeVideoPrivacy obsługuje te opcje:

• PUBLIC: film jest dostępny dla wszystkich użytkowników YouTube. (Dozwolone tylko w przypadku kanałów firmowych).
• UNLISTED: film nie jest widoczny w wynikach wyszukiwania, ale mogą go wyświetlać osoby, które mają do niego link. Jest to opcja domyślna i jedyna dostępna w przypadku kanałów zarządzanych przez Google.

Informowanie o treściach wygenerowanych przez AI

Począwszy od wersji 26, zgodnie z przepisami, takimi jak akt (UE) w sprawie sztucznej inteligencji, reklamodawcy mogą ujawniać, czy przesłane treści wideo zawierają treści wygenerowane przez AI lub media syntetyczne.

Pole video_content_metadata w YouTubeVideoUpload zawiera VideoContentMetadata. Ustaw jego zagnieżdżone generative_content_disclosure pole za pomocą YouTubeVideoUploadGenerativeContentDisclosure typu wyliczeniowego:

Wartość	Opis
NON_GENERATIVE_CONTENT	Reklamodawca poinformował, że film nie został wygenerowany przez AI.
GENERATIVE_CONTENT	Reklamodawca poinformował, że film został wygenerowany przez AI.

Uwaga: video_content_metadata jest polem tylko do wprowadzania danych i można je ustawić tylko podczas tworzenia przesyłania filmu na YouTube. Po utworzeniu nie można go zmienić.

Przesyłanie filmu

Aby przesłać film, musisz użyć żądania wieloczęściowego do metody CreateYouTubeVideoUpload. Żądanie zawiera zarówno metadane przesyłania, jak i sam plik wideo.

1. Inicjowanie przesyłania

Utwórz CreateYouTubeVideoUploadRequest z tymi polami:

Pole	Wymaganie	Opis i ograniczenia
customer_id	Wymagane	10-cyfrowy identyfikator klienta Google Ads (bez łączników).
you_tube_video_upload.video_title	Wymagane (INPUT_ONLY, IMMUTABLE)	Tytuł przesłanego filmu w YouTube (maksymalnie 100 znaków; nie może zawierać znaków < ani >).
you_tube_video_upload.video_description	Opcjonalne (INPUT_ONLY, IMMUTABLE)	Opis filmu w YouTube (maksymalnie 5000 znaków; nie może zawierać znaków < ani >).
you_tube_video_upload.channel_id	Opcjonalne (IMMUTABLE)	Docelowy 24-znakowy identyfikator kanału w YouTube (zaczynający się od UC) w przypadku kanału firmowego należącego do reklamodawcy. Jeśli to pole zostanie pominięte, przesyłanie nastąpi na kanał zarządzany przez Google.
you_tube_video_upload.video_privacy	Opcjonalne (można je zmieniać w przypadku kanałów firmowych)	YouTubeVideoPrivacy ustawienie (UNLISTED jako wartość domyślna lub PUBLIC w przypadku kanałów firmowych należących do reklamodawcy).
you_tube_video_upload.video_content_metadata	Opcjonalne (INPUT_ONLY, IMMUTABLE)	Dostępne od wersji 26: VideoContentMetadata z polem generative_content_disclosure ustawionym na wartość YouTubeVideoUploadGenerativeContentDisclosure (NON_GENERATIVE_CONTENT lub GENERATIVE_CONTENT).

Jeśli używasz biblioteki klienta, wywołaj metodę CreateYouTubeVideoUpload , przekazując plik wideo. Przesyłanie filmu zostanie obsłużone wewnętrznie.

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
      

Jeśli używasz REST, w tej sekcji opisujemy, jak zarządzać przesyłaniem filmów.

2. Przesyłanie filmu

Podczas przesyłania za pomocą REST metoda CreateYouTubeVideoUpload używa dwuetapowego protokołu przesyłania z możliwością wznowienia:

1. Rozpocznij sesję przesyłania: wyślij początkowe żądanie POST do punktu końcowego przesyłania CreateYouTubeVideoUpload (/upload/v26/customers/{customer_id}/youTubeVideoUploads:create) z x-goog-upload-command: start (i opcjonalnie x-goog-upload-header-content-length, aby zadeklarować rozmiar pliku). Odpowiedź zwraca adres URL sesji przesyłania w nagłówku odpowiedzi HTTP x-goog-upload-url wraz z metadanymi, takimi jak oczekiwany rozmiar fragmentu.
2. Przesyłaj strumieniowo i sfinalizuj bajty wideo: wyślij binarny ładunek wideo do punktu końcowego x-goog-upload-url z x-goog-upload-command: upload, finalize. Po zakończeniu przesyłania odpowiedź zwraca utworzoną resource_name (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}).

Pełny opis nagłówków HTTP używanych w protokole przesyłania filmów znajdziesz w tym przykładzie kodu:

# 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. Pobieranie stanu przesyłania filmu

Po rozpoczęciu przesyłania filmu sprawdzaj jego stan przetwarzania, wysyłając zapytania do pól możliwych do wybrania w zasobie you_tube_video_upload (resource_name, video_upload_id, channel_id, video_id, state i video_privacy) za pomocą GAQL, dopóki state = 'PROCESSED' (INPUT_ONLY pola nie mogą być wybierane w 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
      

Zarządzaj przesyłaniem

Po zakończeniu przesyłania filmu możesz go używać jako komponentu wideo.

Używanie przesłanego filmu

Gdy film na YouTube osiągnie stan PROCESSED, jego 11-znakowy identyfikator filmu znajdziesz w polu video_id zasobu YouTubeVideoUpload.

Użyj tego video_id, aby utworzyć YoutubeVideoAsset za pomocą MutateAssets i połączyć uzyskaną nazwę zasobu komponentu (customers/{customer_id}/assets/{asset_id}) z kampaniami lub reklamami:

1. Utwórz YoutubeVideoAsset , przekazując youtube_video_id do AssetService.MutateAssets:

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

2. Połącz Asset z AssetGroup lub AdGroupAd:

   • Kampania Performance Max: utwórz element AssetGroupAsset za pomocą AssetGroupAssetService.MutateAssetGroupAssets z polem field_type ustawionym na 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"
           }
         }
       ]
     }
     

   • Kampania generująca popyt: odwołaj się do customers/{customer_id}/assets/{asset_id} w na liście videos obiektu DemandGenVideoResponsiveAdInfo podczas wywoływania 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. Wysyłaj zapytania do istniejących komponentów YOUTUBE_VIDEO za pomocą 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}'
   

Zaktualizuj metadane

Ustawienie prywatności filmu przesłanego za pomocą tego interfejsu API możesz zaktualizować za pomocą metody UpdateYouTubeVideoUpload z polem update_mask ustawionym na "video_privacy". Po utworzeniu można zaktualizować tylko pole video_privacy (PUBLIC lub UNLISTED w przypadku filmów przesłanych na kanał firmowy należący do reklamodawcy). Pola video_title, video_description, channel_id i video_content_metadata są niezmienne.

Usuwanie przesłanych plików

Jeśli chcesz usunąć filmy przesłane za pomocą interfejsu Google Ads API, przekaż ich customers/{customer_id}/youTubeVideoUploads/{video_upload_id} nazwy zasobów w polu resource_names metody RemoveYouTubeVideoUpload. Spowoduje to usunięcie filmu zarówno z biblioteki komponentów Google Ads, jak i z YouTube.