वीडियो अपलोड करें

ध्यान दें: Google Ads API की मदद से वीडियो अपलोड करने की सुविधा, सिर्फ़ .NET, PHP, और Python क्लाइंट लाइब्रेरी के साथ-साथ REST का इस्तेमाल करके उपलब्ध है. अन्य क्लाइंट लाइब्रेरी के लिए, YouTube Data API v3 का इस्तेमाल करके सीधे वीडियो अपलोड किए जा सकते हैं. साथ ही, YouTube वीडियो के आईडी का इस्तेमाल करके YoutubeVideoAsset बनाया जा सकता है.

YouTubeVideoUploadService की मदद से, Google Ads API के ज़रिए सीधे YouTube पर वीडियो अपलोड किए जा सकते हैं. इसके बाद, इन वीडियो का इस्तेमाल करके, अलग-अलग तरह के विज्ञापनों में वीडियो ऐसेट बनाई जा सकती हैं. जैसे, परफ़ॉर्मेंस मैक्स कैंपेन या मांग बढ़ाने में मदद करने वाले कैंपेन.

यह सेवा, YouTube पर वीडियो अपलोड करने की प्रोसेस को मैनेज करके, वीडियो विज्ञापन बनाने के वर्कफ़्लो को आसान बनाती है. इससे यह पक्का होता है कि वीडियो आपके खाते से सही तरीके से जुड़े हों.

मुख्य सिद्धांत

शुरू करने से पहले, यह समझना ज़रूरी है कि वीडियो अपलोड को कैसे मैनेज किया जाता है और वे किन-किन स्थितियों से गुज़र सकते हैं.

शुरू से आखिर तक का वर्कफ़्लो

किसी वीडियो फ़ाइल को अपलोड करके उसे विज्ञापन में दिखाने के लिए, आपको सिलसिलेवार तरीके से ये चार चरण पूरे करने होंगे:

चरण	सेवा और तरीका	खास जानकारी
1. वीडियो बाइट अपलोड करना और शुरू करना	YouTubeVideoUploadService पर CreateYouTubeVideoUpload	YouTubeVideoUpload रिसॉर्स (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}) बनाने के लिए, वीडियो का मेटाडेटा और बाइनरी फ़ाइल अपलोड करें.
2. पोल प्रोसेस होने की स्थिति	GoogleAdsService पर SearchStream	you_tube_video_upload से लेकर state = 'PROCESSED' तक क्वेरी करें. साथ ही, 11 वर्णों वाला YouTube video_id भरें.
3. फिर से इस्तेमाल की जा सकने वाली वीडियो ऐसेट बनाना	AssetService पर MutateAssets	ऐसेट के संसाधन का नाम (customers/{customer_id}/assets/{asset_id}) पाने के लिए, YoutubeVideoAsset (youtube_video_id = video_id) बनाएं.
4. ऐसेट को कैंपेन या विज्ञापनों से लिंक करना	AssetGroupAssetService पर MutateAssetGroupAssets या AdGroupAdService पर MutateAdGroupAds	ऐसेट को परफ़ॉर्मेंस मैक्स AssetGroupAsset (field_type = YOUTUBE_VIDEO) या मांग बढ़ाने में मदद करने वाले कैंपेन DemandGenVideoResponsiveAdInfo (videos[].asset) से लिंक करें.

चैनल स्वामित्व

कोई वीडियो अपलोड करते समय, यह तय किया जा सकता है कि उसे किस YouTube चैनल पर अपलोड करना है. इसके लिए, YouTubeVideoUpload रिसॉर्स में मौजूद channel_id फ़ील्ड का इस्तेमाल करें:

• विज्ञापन देने वाले व्यक्ति या कंपनी के मालिकाना हक वाला (ब्रैंड) चैनल: विज्ञापन देने वाले व्यक्ति या कंपनी के मालिकाना हक वाले मौजूदा YouTube चैनल का channel_id दें. यह सिर्फ़ उपयोगकर्ता की पुष्टि के फ़्लो के साथ काम करता है. इसका इस्तेमाल सेवा खातों के साथ नहीं किया जा सकता.
• Google खाते से मैनेज किया जा रहा चैनल: अगर channel_id को शामिल नहीं किया जाता है, तो वीडियो को Google खाते से मैनेज किए जा रहे उस YouTube चैनल पर अपलोड किया जाता है जो Google Ads खाते से जुड़ा है.

अपलोड की गई फ़ाइलों की स्थिति

YouTube पर अपलोड किए गए वीडियो की लाइफ़साइकल को state फ़ील्ड से ट्रैक किया जाता है. YouTubeVideoUploadState enum से इन स्थितियों के बारे में पता चलता है:

राज्य	ब्यौरा
PENDING	वीडियो अपलोड किया जा रहा है.
UPLOADED	वीडियो अपलोड हो गया है और YouTube इसे प्रोसेस कर रहा है.
PROCESSED	वीडियो को प्रोसेस कर दिया गया है और अब इसका इस्तेमाल किया जा सकता है.
FAILED	अपलोड या प्रोसेस करने की प्रोसेस पूरी नहीं हो सकी.
REJECTED	पुष्टि न होने या नीति के उल्लंघन की वजह से, वीडियो को अस्वीकार कर दिया गया.
UNAVAILABLE	वीडियो की स्थिति उपलब्ध नहीं है. ऐसा हो सकता है कि उसे YouTube से हटा दिया गया हो.

निजता सेटिंग

video_privacy फ़ील्ड से यह कंट्रोल किया जाता है कि अपलोड किया गया वीडियो किसे दिखे. YouTubeVideoPrivacy ईनम में ये वैल्यू इस्तेमाल की जा सकती हैं:

• PUBLIC: यह वीडियो YouTube पर सभी के लिए उपलब्ध है. (सिर्फ़ ब्रैंड चैनलों के लिए अनुमति है).
• UNLISTED: वीडियो को खोजा नहीं जा सकता. हालांकि, जिसके पास वीडियो का लिंक है वह इसे देख सकता है. Google की ओर से मैनेज किए जाने वाले चैनलों के लिए, यह डिफ़ॉल्ट और एकमात्र विकल्प है.

जनरेटिव कॉन्टेंट के बारे में जानकारी देना

विज्ञापन देने वाले लोग या कंपनियां, v26 से ईयू एआई ऐक्ट जैसे नियमों के तहत यह जानकारी दे सकती हैं कि अपलोड किए गए वीडियो कॉन्टेंट में, एआई से जनरेट किया गया या सिंथेटिक मीडिया शामिल है या नहीं.

YouTubeVideoUpload में मौजूद video_content_metadata फ़ील्ड में VideoContentMetadata शामिल है. YouTubeVideoUploadGenerativeContentDisclosure enum का इस्तेमाल करके, इसके नेस्ट किए गए generative_content_disclosure फ़ील्ड को सेट करें:

वैल्यू	ब्यौरा
NON_GENERATIVE_CONTENT	विज्ञापन देने वाले व्यक्ति या कंपनी ने बताया कि वीडियो को एआई से नहीं बनाया गया है.
GENERATIVE_CONTENT	विज्ञापन देने वाले व्यक्ति या कंपनी ने बताया है कि वीडियो को एआई से बनाया गया है.

ध्यान दें: video_content_metadata सिर्फ़ इनपुट के लिए है. इसे YouTube वीडियो अपलोड करते समय ही सेट किया जा सकता है. इसे बनाने के बाद बदला नहीं जा सकता.

वीडियो अपलोड करें

वीडियो अपलोड करने के लिए, आपको CreateYouTubeVideoUpload तरीके का इस्तेमाल करके, कई हिस्सों वाला अनुरोध करना होगा. अनुरोध में, अपलोड किए जाने वाले वीडियो का मेटाडेटा और वीडियो फ़ाइल, दोनों शामिल होती हैं.

1. अपलोड शुरू करना

इन फ़ील्ड के साथ CreateYouTubeVideoUploadRequest बनाएं:

फ़ील्ड	आवश्यकता	ब्यौरा और सीमाएं
customer_id	ज़रूरी है	10 अंकों का Google Ads ग्राहक आईडी (बिना हाइफ़न के).
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)	विज्ञापन देने वाले व्यक्ति या कंपनी के ब्रैंड चैनल के लिए, 24 वर्णों वाला डेस्टिनेशन YouTube चैनल आईडी (UC से शुरू होने वाला). अगर इसे शामिल नहीं किया जाता है, तो वीडियो को Google खाते से मैनेज किए जा रहे चैनल पर अपलोड किया जाता है.
you_tube_video_upload.video_privacy	ज़रूरी नहीं (ब्रैंड चैनलों पर इसे बदला जा सकता है)	YouTubeVideoPrivacy सेटिंग (UNLISTED डिफ़ॉल्ट या विज्ञापन देने वाले व्यक्ति या कंपनी के मालिकाना हक वाले ब्रैंड चैनलों के लिए PUBLIC).
you_tube_video_upload.video_content_metadata	ज़रूरी नहीं (INPUT_ONLY, IMMUTABLE)	Android 13 (API लेवल 33) और इससे ऊपर के वर्शन पर उपलब्ध है: 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 दो चरणों वाले फिर से अपलोड किए जा सकने वाले प्रोटोकॉल का इस्तेमाल करता है:

1. अपलोड सेशन शुरू करना: CreateYouTubeVideoUpload अपलोड एंडपॉइंट (/upload/v26/customers/{customer_id}/youTubeVideoUploads:create) पर शुरुआती POST अनुरोध भेजें. इसके साथ, x-goog-upload-command: start भेजें. फ़ाइल का साइज़ बताने के लिए, x-goog-upload-header-content-length भी भेजा जा सकता है. जवाब में, अपलोड सेशन का यूआरएल x-goog-upload-url एचटीटीपी रिस्पॉन्स हेडर में दिखता है. साथ ही, इसमें मेटाडेटा भी होता है. जैसे, अनुमानित चंक साइज़.
2. वीडियो बाइट स्ट्रीम करें और उन्हें फ़ाइनल करें: बाइनरी वीडियो पेलोड को x-goog-upload-url एंडपॉइंट पर x-goog-upload-command: upload, finalize के साथ भेजें. अपलोड पूरा होने पर, रिस्पॉन्स में बनाया गया resource_name (customers/{customer_id}/youTubeVideoUploads/{video_upload_id}) दिखता है.

वीडियो अपलोड करने के प्रोटोकॉल में इस्तेमाल किए गए एचटीटीपी हेडर के बारे में पूरी जानकारी के लिए, कोड का यह उदाहरण देखें:

# 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. वीडियो अपलोड होने की स्थिति का पता लगाना

वीडियो अपलोड करने के बाद, GAQL का इस्तेमाल करके you_tube_video_upload संसाधन के चुने जा सकने वाले फ़ील्ड (resource_name, video_upload_id, channel_id, video_id, state, और video_privacy) को क्वेरी करें. इससे वीडियो की प्रोसेसिंग की स्थिति का पता चलेगा. ऐसा तब तक करें, जब तक state = 'PROCESSED' (GAQL में INPUT_ONLY फ़ील्ड नहीं चुने जा सकते):

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 स्थिति में पहुंच जाता है, तब आपको YouTubeVideoUpload संसाधन के video_id फ़ील्ड में, YouTube वीडियो का 11 वर्णों वाला आईडी मिल सकता है.

YoutubeVideoAsset बनाने के लिए, इस video_id का इस्तेमाल करें. साथ ही, MutateAssets जोड़ें और नतीजे में मिले ऐसेट रिसॉर्स के नाम (customers/{customer_id}/assets/{asset_id}) को अपने कैंपेन या विज्ञापनों से लिंक करें:

1. AssetService.MutateAssets में youtube_video_id को पास करके, YoutubeVideoAsset बनाएं:

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

2. Asset को AssetGroup या AdGroupAd से लिंक करें:

   • परफ़ॉर्मेंस मैक्स कैंपेन: AssetGroupAssetService.MutateAssetGroupAssets का इस्तेमाल करके AssetGroupAsset बनाएं. इसमें 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"
           }
         }
       ]
     }
     

   • मांग बढ़ाने में मदद करने वाला कैंपेन: AdGroupAdService.MutateAdGroupAds को कॉल करते समय, DemandGenVideoResponsiveAdInfo ऑब्जेक्ट की videos सूची में 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"
                 }
               }
             }
           }
         }
       ]
     }
     

3. GoogleAdsService.SearchStream का इस्तेमाल करके, मौजूदा YOUTUBE_VIDEO ऐसेट के बारे में क्वेरी करना:

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

मेटाडेटा अपडेट करें

इस एपीआई के ज़रिए अपलोड किए गए वीडियो की निजता सेटिंग को अपडेट किया जा सकता है. इसके लिए, UpdateYouTubeVideoUpload तरीके का इस्तेमाल करें. इसमें update_mask को "video_privacy" पर सेट करें. विज्ञापन बनाने के बाद, सिर्फ़ video_privacy फ़ील्ड (विज्ञापन देने वाले व्यक्ति या कंपनी के मालिकाना हक वाले ब्रैंड चैनल पर अपलोड किए गए वीडियो के लिए, PUBLIC या UNLISTED) को अपडेट किया जा सकता है. video_title, video_description, channel_id, और video_content_metadata में बदलाव नहीं किया जा सकता.

अपलोड किए गए वीडियो हटाना

अगर आपको Google Ads API की मदद से अपलोड किए गए वीडियो मिटाने हैं, तो RemoveYouTubeVideoUpload तरीके के resource_names फ़ील्ड में उनके customers/{customer_id}/youTubeVideoUploads/{video_upload_id} संसाधन के नाम डालें. इससे वीडियो, Google Ads की ऐसेट लाइब्रेरी और YouTube, दोनों से हट जाता है.