Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Videos hochladen

Mit der YouTubeVideoUploadService können Sie Videos über die Google Ads API direkt auf YouTube hochladen. Diese Videos können dann verwendet werden, um Video-Assets in verschiedenen Anzeigentypen zu erstellen, z. B. in Performance Max-Kampagnen oder Demand Gen-Kampagnen.

Dieser Dienst optimiert den Workflow zum Erstellen von Videoanzeigen, indem er den YouTube-Uploadprozess übernimmt und dafür sorgt, dass die Videos Ihrem Konto richtig zugeordnet werden.

Wichtige Konzepte

Bevor Sie beginnen, sollten Sie sich damit vertraut machen, wie Videouploads verwaltet werden und welche verschiedenen Status sie durchlaufen können.

End-to-End-Workflow

Das Hochladen einer Videodatei und die Auslieferung in einer Anzeige erfordert vier aufeinanderfolgende Schritte:

Schritt	Dienst und Methode	Zusammenfassung
1. Videobytes initiieren und hochladen	`CreateYouTubeVideoUpload` über `YouTubeVideoUploadService`	Laden Sie die Videometadaten und die Binärdatei hoch, um eine `YouTubeVideoUpload`-Ressource (`customers/{customer_id}/youTubeVideoUploads/{video_upload_id}`) zu erstellen.
2. Verarbeitungsstatus abfragen	`SearchStream` über `GoogleAdsService`	Frage `you_tube_video_upload` bis `state = 'PROCESSED'` ab. Die 11-stellige YouTube-`video_id` wird ausgefüllt.
3. Wiederverwendbares Video-Asset erstellen	`MutateAssets` über `AssetService`	Erstellen Sie eine `YoutubeVideoAsset` (`youtube_video_id = video_id`), um einen Asset-Ressourcennamen (`customers/{customer_id}/assets/{asset_id}`) zu erhalten.
4. Asset mit Kampagnen oder Anzeigen verknüpfen	`MutateAssetGroupAssets` am `AssetGroupAssetService` oder `MutateAdGroupAds` am `AdGroupAdService`	Verknüpfen Sie das Asset mit einer Performance Max-Kampagne `AssetGroupAsset` (`field_type = YOUTUBE_VIDEO`) oder einer Demand Gen-Kampagne `DemandGenVideoResponsiveAdInfo` (`videos[].asset`).

Kanalzugehörigkeit

Wenn du ein Video hochlädst, kannst du den YouTube-Zielkanal mit dem Feld channel_id in der Ressource YouTubeVideoUpload angeben:

Kanal des Werbetreibenden (Markenkanal):Geben Sie die channel_id eines vorhandenen YouTube-Kanals des Werbetreibenden an. Dies wird nur mit dem Nutzerauthentifizierungsablauf unterstützt und kann nicht mit Dienstkonten verwendet werden.
Von Google verwalteter Kanal:Wenn channel_id weggelassen wird, wird das Video auf einen von Google verwalteten YouTube-Kanal hochgeladen, der mit dem Google Ads-Konto verknüpft ist.

Uploadstatus

Der Lebenszyklus eines YouTube-Videouploads wird im Feld state erfasst. Das Enum YouTubeVideoUploadState definiert die folgenden Status:

Bundesland	Beschreibung
`PENDING`	Das Video wird hochgeladen.
`UPLOADED`	Das Video wurde hochgeladen und wird von YouTube verarbeitet.
`PROCESSED`	Das Video wurde erfolgreich verarbeitet und kann jetzt verwendet werden.
`FAILED`	Der Upload oder die Verarbeitung ist fehlgeschlagen und kann nicht abgeschlossen werden.
`REJECTED`	Das Video wurde aufgrund von Validierungs- oder Richtlinienproblemen abgelehnt.
`UNAVAILABLE`	Der Videostatus ist nicht verfügbar. Das Video wurde möglicherweise von YouTube entfernt.

Datenschutzeinstellungen

Über das Feld video_privacy wird festgelegt, wer das hochgeladene Video sehen kann. Das Enum YouTubeVideoPrivacy unterstützt:

PUBLIC: Das Video ist für alle auf YouTube verfügbar. (Nur für Markenkanäle zulässig).
UNLISTED: Das Video kann nicht gesucht werden, aber jeder, der den Link hat, kann es sich ansehen. Dies ist die Standardeinstellung und die einzige Option für von Google verwaltete Kanäle.

Anforderungen an Titel und Beschreibung

Wenn du einen Video-Upload erstellst, kannst du Metadaten mit den Feldern video_title und video_description in der Ressource YouTubeVideoUpload angeben:

video_title: Erforderlich. Der Titel darf höchstens 100 Zeichen lang sein und keine ungültigen Zeichen (Spitzklammern < oder >) enthalten. Er kann nur beim Erstellen des Video-Uploads festgelegt werden und ist danach unveränderlich.
video_description (optional). Die Beschreibung darf maximal 5.000 Zeichen lang sein und keine ungültigen Zeichen (Spitzklammern < oder >) enthalten. Sie kann nur beim Erstellen des Video-Uploads festgelegt werden und ist danach unveränderlich.

Beide Felder sind nach der Erstellung unveränderlich. Wenn Sie video_title oder video_description in die Aktualisierungsmaske einer UpdateYouTubeVideoUpload-Anfrage aufnehmen, schlägt die Anfrage mit dem Fehler FieldError.IMMUTABLE_FIELD fehl.

Weitere Informationen zur Formatierung von YouTube-Titeln und ‑Beschreibungen sowie zu ungültigen Zeichen findest du in der YouTube-Hilfe.

Offenlegung von generativen Inhalten

Ab Version 26 können Werbetreibende gemäß Verordnungen wie dem EU-Gesetz über künstliche Intelligenz offenlegen, ob hochgeladene Videoinhalte KI-generierte oder synthetische Medien enthalten.

Das Feld video_content_metadata in YouTubeVideoUpload enthält VideoContentMetadata. Legen Sie das verschachtelte Feld generative_content_disclosure mit dem Enum YouTubeVideoUploadGenerativeContentDisclosure fest:

Wert	Beschreibung
`NON_GENERATIVE_CONTENT`	Der Werbetreibende hat angegeben, dass das Video nicht KI-generiert ist.
`GENERATIVE_CONTENT`	Der Werbetreibende hat das Video als KI-generiert gekennzeichnet.

Video hochladen

Wenn du ein Video hochladen möchtest, musst du eine mehrteilige Anfrage an die Methode CreateYouTubeVideoUpload senden. Die Anfrage enthält sowohl die Metadaten für den Upload als auch die Videodatei selbst.

1. Upload starten

Erstellen Sie ein CreateYouTubeVideoUploadRequest mit den folgenden Feldern:

Feld	Anforderung	Beschreibung und Einschränkungen
`customer_id`	Erforderlich	Die zehnstellige Google Ads-Kundennummer (ohne Bindestriche).
`you_tube_video_upload.video_title`	Erforderlich (`INPUT_ONLY`, `IMMUTABLE`)	Titel des hochgeladenen Videos auf YouTube (bis zu 100 Zeichen; darf nicht `<` oder `>` enthalten).
`you_tube_video_upload.video_description`	Optional (`INPUT_ONLY`, `IMMUTABLE`)	Beschreibung des Videos auf YouTube (bis zu 5.000 Zeichen; darf nicht `<` oder `>` enthalten).
`you_tube_video_upload.channel_id`	Optional (`IMMUTABLE`)	24-stellige Ziel-Kanal-ID des YouTube-Kanals (beginnend mit `UC`) für einen Markenkanal des Werbetreibenden. Wenn Sie das Feld weglassen, werden die Videos in einen von Google verwalteten Kanal hochgeladen.
`you_tube_video_upload.video_privacy`	Optional (auf Markenkanälen änderbar)	`YouTubeVideoPrivacy`-Einstellung (`UNLISTED` ist die Standardeinstellung, `PUBLIC` für Markenkanäle von Werbetreibenden).
`you_tube_video_upload.video_content_metadata`	Optional (`INPUT_ONLY`, `IMMUTABLE`)	Verfügbar ab Version 26: `VideoContentMetadata`, wobei `generative_content_disclosure` auf einen `YouTubeVideoUploadGenerativeContentDisclosure`-Wert (`NON_GENERATIVE_CONTENT` oder `GENERATIVE_CONTENT`) festgelegt ist.

Wenn Sie eine Clientbibliothek verwenden, rufen Sie die Methode CreateYouTubeVideoUpload auf und übergeben Sie Ihre Videodatei. Der Video-Upload wird dann intern verarbeitet.

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

Wenn Sie REST verwenden, wird im folgenden Abschnitt beschrieben, wie Sie den Video-Upload verwalten.

2. Video hochladen

Beim Hochladen mit REST verwendet CreateYouTubeVideoUpload ein zweistufiges Protokoll für fortsetzbare Uploads:

Uploadsitzung starten: Senden Sie eine erste POST-Anfrage an den Upload-Endpunkt CreateYouTubeVideoUpload (/upload/v26/customers/{customer_id}/youTubeVideoUploads:create) mit x-goog-upload-command: start (und optional x-goog-upload-header-content-length, um die Dateigröße anzugeben). Die Antwort gibt die URL der Uploadsitzung im HTTP-Antwortheader x-goog-upload-url zusammen mit Metadaten wie der erwarteten Blockgröße zurück.
Videobytes streamen und finalisieren: Senden Sie die binäre Videonutzlast mit x-goog-upload-command: upload, finalize an den Endpunkt x-goog-upload-url. Wenn der Upload abgeschlossen ist, wird in der Antwort die erstellte resource_name (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}) zurückgegeben.

Eine vollständige Beschreibung der im Protokoll für den Videoupload verwendeten HTTP-Header finden Sie im folgenden Codebeispiel:

# 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. Status des Video-Uploads abrufen

Nachdem Sie einen Videoupload gestartet haben, können Sie den Verarbeitungsstatus abfragen. Dazu rufen Sie die auswählbaren Felder der Ressource you_tube_video_upload (resource_name, video_upload_id, channel_id, video_id, state und video_privacy) mit GAQL ab, bis state = 'PROCESSED' (INPUT_ONLY-Felder können in GAQL nicht ausgewählt werden):

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
endupload_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'"
}
EOFupload_video.sh

Uploads verwalten

Nachdem ein Video hochgeladen wurde, können Sie es als Video-Asset verwenden.

Hochgeladenes Video verwenden

Wenn ein Video den Status PROCESSED erreicht, findest du die elfstellige YouTube-Video-ID im Feld video_id der Ressource YouTubeVideoUpload.

Verwenden Sie diesen video_id, um mit MutateAssets ein YoutubeVideoAsset zu erstellen, und verknüpfen Sie den resultierenden Asset-Ressourcennamen (customers/{customer_id}/assets/{asset_id}) mit Ihren Kampagnen oder Anzeigen:

Erstellen Sie die YoutubeVideoAsset, indem Sie youtube_video_id an AssetService.MutateAssets übergeben:

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

Asset mit einem AssetGroup oder AdGroupAd verknüpfen:

Performance Max-Kampagne:Erstellen Sie eine AssetGroupAsset mit AssetGroupAssetService.MutateAssetGroupAssets, wobei field_type auf YOUTUBE_VIDEO festgelegt ist:

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: Verweisen Sie beim Aufruf von AdGroupAdService.MutateAdGroupAds in der videos-Liste eines DemandGenVideoResponsiveAdInfo-Objekts auf customers/{customer_id}/assets/{asset_id}:

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

Vorhandene YOUTUBE_VIDEO-Assets mit GoogleAdsService.SearchStream abfragen:

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

Metadaten aktualisieren

Sie können die Datenschutzeinstellung eines über diese API hochgeladenen Videos mit der Methode UpdateYouTubeVideoUpload aktualisieren, wobei update_mask auf "video_privacy" gesetzt ist. Nach dem Erstellen kann nur das Feld video_privacy (PUBLIC oder UNLISTED für Videos, die auf einen Markenkanal des Werbetreibenden hochgeladen wurden) aktualisiert werden. video_title, video_description, channel_id und video_content_metadata können nicht geändert werden. Wenn Sie video_title oder video_description in die Aktualisierungsmaske aufnehmen, schlägt dies mit dem Fehler FieldError.IMMUTABLE_FIELD fehl.

Uploads entfernen

Wenn Sie Videos löschen möchten, die mit der Google Ads API hochgeladen wurden, übergeben Sie die customers/{customer_id}/youTubeVideoUploads/{video_upload_id}-Ressourcennamen im Feld resource_names der Methode RemoveYouTubeVideoUpload. Dadurch wird das Video sowohl aus der Google Ads-Asset-Bibliothek als auch von YouTube entfernt.

Zurück

Assets für Nachricht an das Unternehmen

Weiter

Berichterstellung

Videos hochladen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Wichtige Konzepte

End-to-End-Workflow

Kanalzugehörigkeit

Uploadstatus

Datenschutzeinstellungen

Anforderungen an Titel und Beschreibung

Offenlegung von generativen Inhalten

Video hochladen

1. Upload starten

Java

C#

PHP

Python

Ruby

Perl

curl

2. Video hochladen

3. Status des Video-Uploads abrufen

Java

C#

PHP

Python

Ruby

Perl

curl

Uploads verwalten

Hochgeladenes Video verwenden

Metadaten aktualisieren

Uploads entfernen

Videos hochladen