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

Videos hochladen

Der YouTubeVideoUploadService können Sie Videos direkt über die Google Ads API 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 für die Erstellung von Videoanzeigen, indem er den YouTube-Uploadprozess übernimmt und dafür sorgt, dass die Videos korrekt mit Ihrem Konto verknüpft werden.

Wichtige Konzepte

Bevor Sie beginnen, sollten Sie wissen, wie Video-Uploads verwaltet werden und welche verschiedenen Status sie durchlaufen können.

End-to-End-Workflow

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

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

Kanalzugehörigkeit

Wenn Sie ein Video hochladen, können Sie den Ziel-YouTube-Kanal über das channel_id Feld in der YouTubeVideoUpload Ressource angeben:

Kanal im Besitz des Werbetreibenden (Markenkanal):Geben Sie die channel_id eines vorhandenen YouTube-Kanals an, der dem Werbetreibenden gehört. Dies wird nur mit dem Nutzerauthentifizierungsablauf unterstützt und kann nicht mit Dienstkonten verwendet werden.
Von Google verwalteter Kanal:Wenn channel_id nicht angegeben 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-Video-Uploads wird über das Feld state verfolgt. Das YouTubeVideoUploadState Enum definiert die folgenden Status:

Status	Beschreibung
`PENDING`	Das Video wird hochgeladen.
`UPLOADED`	Das Video wurde erfolgreich hochgeladen und wird von YouTube verarbeitet.
`PROCESSED`	Das Video wurde erfolgreich verarbeitet und kann verwendet werden.
`FAILED`	Der Upload oder die Verarbeitung ist fehlgeschlagen und kann nicht abgeschlossen werden.
`REJECTED`	Das Video wurde aus Validierungs- oder Richtliniengründen 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 YouTubeVideoPrivacy Enum unterstützt folgende Einstellungen:

PUBLIC: Das Video ist für alle Nutzer auf YouTube verfügbar. (Nur für Markenkanäle zulässig)
UNLISTED: Das Video ist nicht in der Suche zu finden, kann aber von allen Nutzern mit dem Link angesehen werden. Dies ist die Standardeinstellung und die einzige Option für von Google verwaltete Kanäle.

Offenlegung generativer Inhalte

Ab Version 26 können Werbetreibende gemäß Verordnungen wie dem EU AI Act offenlegen, ob hochgeladene Videoinhalte mit KI generierte oder synthetische Medien enthalten.

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

Wert	Beschreibung
`NON_GENERATIVE_CONTENT`	Der Werbetreibende hat das Video als nicht mit KI generiert offengelegt.
`GENERATIVE_CONTENT`	Der Werbetreibende hat das Video als mit KI generiert offengelegt.

Video hochladen

Wenn Sie ein Video hochladen möchten, müssen Sie eine Multipart-Anfrage an die Methode CreateYouTubeVideoUpload senden. Die Anfrage enthält sowohl die Metadaten für den Upload als auch die Videodatei selbst.

1. Upload initiieren

Erstellen Sie eine 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 keine Zeichen `<` oder `>` enthalten).
`you_tube_video_upload.video_description`	Optional (`INPUT_ONLY`, `IMMUTABLE`)	Beschreibung des Videos auf YouTube (bis zu 5.000 Zeichen; darf keine Zeichen `<` oder `>` enthalten).
`you_tube_video_upload.channel_id`	Optional (`IMMUTABLE`)	24-stellige YouTube-Kanal-ID (beginnend mit `UC`) für einen Markenkanal im Besitz des Werbetreibenden. Wenn nicht angegeben, werden Uploads auf einen von Google verwalteten Kanal hochgeladen.
`you_tube_video_upload.video_privacy`	Optional (auf Markenkanälen veränderbar)	`YouTubeVideoPrivacy` -Einstellung (`UNLISTED` als Standard oder `PUBLIC` für Markenkanäle im Besitz des Werbetreibenden).
`you_tube_video_upload.video_content_metadata`	Optional (`INPUT_ONLY`, `IMMUTABLE`)	Ab Version 26 verfügbar: `VideoContentMetadata` mit `generative_content_disclosure` auf einen `YouTubeVideoUploadGenerativeContentDisclosure`-Wert gesetzt (`NON_GENERATIVE_CONTENT` oder `GENERATIVE_CONTENT`).

Wenn Sie eine Clientbibliothek verwenden, rufen Sie die CreateYouTubeVideoUpload Methode auf und übergeben Sie Ihre Videodatei. Der Video-Upload wird 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 fortsetzbares Uploadprotokoll:

Uploadsitzung starten: Senden Sie eine erste POST Anfrage an den CreateYouTubeVideoUpload Upload-Endpunkt (/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 Uploadsitzungs-URL im HTTP-Antwortheader x-goog-upload-url zurück, zusammen mit Metadaten wie der erwarteten Chunk-Größe.
Video-Bytes streamen und abschließen:Senden Sie die binäre Videonutzlast an den Endpunkt x-goog-upload-url mit x-goog-upload-command: upload, finalize. Nach Abschluss des Uploads gibt die Antwort den erstellten resource_name zurück (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}).

Eine vollständige Beschreibung der HTTP-Header, die im Video-Uploadprotokoll verwendet werden, 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 Video-Upload gestartet haben, können Sie den Verarbeitungsstatus abfragen, indem Sie die auswählbaren Felder der you_tube_video_upload Ressource (resource_name, video_upload_id, channel_id, video_id, state, und video_privacy) mit GAQL abfragen, bis state = 'PROCESSED' ist. (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-Upload abgeschlossen ist, können Sie es als Video-Asset verwenden.

Hochgeladenes Video verwenden

Sobald ein Video den Status PROCESSED erreicht hat, finden Sie die 11-stellige YouTube-Video-ID im Feld video_id der Ressource YouTubeVideoUpload.

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

Erstellen Sie das 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"
        }
      }
    }
  ]
}

Verknüpfen Sie das Asset mit einem AssetGroup oder AdGroupAd:

Performance Max-Kampagne:Erstellen Sie ein AssetGroupAsset mit AssetGroupAssetService.MutateAssetGroupAssets und setzen Sie field_type auf 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:Verweisen Sie beim Aufrufen von AdGroupAdService.MutateAdGroupAds in der Liste videos 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 abfragen mit 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}'

Metadaten aktualisieren

Sie können die Datenschutzeinstellung eines über diese API hochgeladenen Videos mit der UpdateYouTubeVideoUpload Methode aktualisieren. Setzen Sie dazu update_mask auf "video_privacy". Nach der Erstellung kann nur das Feld video_privacy (PUBLIC oder UNLISTED für Videos, die auf einen Markenkanal im Besitz des Werbetreibenden hochgeladen wurden) aktualisiert werden. video_title, video_description, channel_id und video_content_metadata sind unveränderlich.

Uploads entfernen

Wenn Sie Videos löschen müssen, die mit der Google Ads API hochgeladen wurden, übergeben Sie die customers/{customer_id}/youTubeVideoUploads/{video_upload_id} Ressourcennamen im Feld resource_names der RemoveYouTubeVideoUpload Methode. 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

Offenlegung generativer Inhalte

Video hochladen

1. Upload initiieren

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