고객 목록 업데이트, 삭제, 보고는 이 가이드를 참고하세요.
오프라인 사용자 데이터 작업 서비스로 목록 업데이트
고객 목록을 만들고 타겟팅을 설정한 후에는 정기적으로 새로고침하세요.
목록을 최신 데이터로 업데이트하는 것이 일반적으로는 더 효율적입니다. 목록에서 모든 사용자를 삭제하지 않고 개별 사용자 추가 또는 삭제 처음부터 업로드합니다.
목록에 추가
기존 목록에 추가하려면 같은 방식으로 OfflineUserDataJob를 만듭니다.
새 고객 목록을 만들 때처럼 말이죠
자바
private void addUsersToCustomerMatchUserList(
GoogleAdsClient googleAdsClient,
long customerId,
boolean runJob,
String userListResourceName,
Long offlineUserDataJobId,
ConsentStatus adPersonalizationConsent,
ConsentStatus adUserDataConsent)
throws UnsupportedEncodingException {
try (OfflineUserDataJobServiceClient offlineUserDataJobServiceClient =
googleAdsClient.getLatestVersion().createOfflineUserDataJobServiceClient()) {
String offlineUserDataJobResourceName;
if (offlineUserDataJobId == null) {
// Creates a new offline user data job.
OfflineUserDataJob.Builder offlineUserDataJobBuilder =
OfflineUserDataJob.newBuilder()
.setType(OfflineUserDataJobType.CUSTOMER_MATCH_USER_LIST)
.setCustomerMatchUserListMetadata(
CustomerMatchUserListMetadata.newBuilder().setUserList(userListResourceName));
// Adds consent information to the job if specified.
if (adPersonalizationConsent != null || adUserDataConsent != null) {
Consent.Builder consentBuilder = Consent.newBuilder();
if (adPersonalizationConsent != null) {
consentBuilder.setAdPersonalization(adPersonalizationConsent);
}
if (adUserDataConsent != null) {
consentBuilder.setAdUserData(adUserDataConsent);
}
// Specifies whether user consent was obtained for the data you are uploading. See
// https://www.google.com/about/company/user-consent-policy for details.
offlineUserDataJobBuilder
.getCustomerMatchUserListMetadataBuilder()
.setConsent(consentBuilder);
}
// Issues a request to create the offline user data job.
CreateOfflineUserDataJobResponse createOfflineUserDataJobResponse =
offlineUserDataJobServiceClient.createOfflineUserDataJob(
Long.toString(customerId), offlineUserDataJobBuilder.build());
offlineUserDataJobResourceName = createOfflineUserDataJobResponse.getResourceName();
System.out.printf(
"Created an offline user data job with resource name: %s.%n",
offlineUserDataJobResourceName);
} else {
// Reuses the specified offline user data job.
offlineUserDataJobResourceName =
ResourceNames.offlineUserDataJob(customerId, offlineUserDataJobId);
}
// Issues a request to add the operations to the offline user data job. This example
// only adds a few operations, so it only sends one AddOfflineUserDataJobOperations request.
// If your application is adding a large number of operations, split the operations into
// batches and send multiple AddOfflineUserDataJobOperations requests for the SAME job. See
// https://developers.google.com/google-ads/api/docs/remarketing/audience-types/customer-match#customer_match_considerations
// and https://developers.google.com/google-ads/api/docs/best-practices/quotas#user_data
// for more information on the per-request limits.
List<OfflineUserDataJobOperation> userDataJobOperations = buildOfflineUserDataJobOperations();
AddOfflineUserDataJobOperationsResponse response =
offlineUserDataJobServiceClient.addOfflineUserDataJobOperations(
AddOfflineUserDataJobOperationsRequest.newBuilder()
.setResourceName(offlineUserDataJobResourceName)
.setEnablePartialFailure(true)
.addAllOperations(userDataJobOperations)
.build());
// Prints the status message if any partial failure error is returned.
// NOTE: The details of each partial failure error are not printed here, you can refer to
// the example HandlePartialFailure.java to learn more.
if (response.hasPartialFailureError()) {
GoogleAdsFailure googleAdsFailure =
ErrorUtils.getInstance().getGoogleAdsFailure(response.getPartialFailureError());
System.out.printf(
"Encountered %d partial failure errors while adding %d operations to the offline user "
+ "data job: '%s'. Only the successfully added operations will be executed when "
+ "the job runs.%n",
googleAdsFailure.getErrorsCount(),
userDataJobOperations.size(),
response.getPartialFailureError().getMessage());
} else {
System.out.printf(
"Successfully added %d operations to the offline user data job.%n",
userDataJobOperations.size());
}
if (!runJob) {
System.out.printf(
"Not running offline user data job '%s', as requested.%n",
offlineUserDataJobResourceName);
return;
}
// Issues an asynchronous request to run the offline user data job for executing
// all added operations.
offlineUserDataJobServiceClient.runOfflineUserDataJobAsync(offlineUserDataJobResourceName);
// BEWARE! The above call returns an OperationFuture. The execution of that future depends on
// the thread pool which is owned by offlineUserDataJobServiceClient. If you use this future,
// you *must* keep the service client in scope too.
// See https://developers.google.com/google-ads/api/docs/client-libs/java/lro for more detail.
// Offline user data jobs may take 6 hours or more to complete, so instead of waiting for the
// job to complete, retrieves and displays the job status once. If the job is completed
// successfully, prints information about the user list. Otherwise, prints the query to use
// to check the job again later.
checkJobStatus(googleAdsClient, customerId, offlineUserDataJobResourceName);
}
}
C#
private static string AddUsersToCustomerMatchUserList(GoogleAdsClient client,
long customerId, string userListResourceName, bool runJob,
long? offlineUserDataJobId, ConsentStatus? adPersonalizationConsent,
ConsentStatus? adUserDataConsent)
{
// Get the OfflineUserDataJobService.
OfflineUserDataJobServiceClient service = client.GetService(
Services.V17.OfflineUserDataJobService);
string offlineUserDataJobResourceName;
if (offlineUserDataJobId == null)
{
// Creates a new offline user data job.
OfflineUserDataJob offlineUserDataJob = new OfflineUserDataJob()
{
Type = OfflineUserDataJobType.CustomerMatchUserList,
CustomerMatchUserListMetadata = new CustomerMatchUserListMetadata()
{
UserList = userListResourceName,
}
};
if (adUserDataConsent != null || adPersonalizationConsent != null)
{
// Specifies whether user consent was obtained for the data you are uploading.
// See https://www.google.com/about/company/user-consent-policy
// for details.
offlineUserDataJob.CustomerMatchUserListMetadata.Consent = new Consent();
if (adPersonalizationConsent != null)
{
offlineUserDataJob.CustomerMatchUserListMetadata.Consent.AdPersonalization =
(ConsentStatus)adPersonalizationConsent;
}
if (adUserDataConsent != null)
{
offlineUserDataJob.CustomerMatchUserListMetadata.Consent.AdUserData =
(ConsentStatus)adUserDataConsent;
}
}
// Issues a request to create the offline user data job.
CreateOfflineUserDataJobResponse response1 = service.CreateOfflineUserDataJob(
customerId.ToString(), offlineUserDataJob);
offlineUserDataJobResourceName = response1.ResourceName;
Console.WriteLine($"Created an offline user data job with resource name: " +
$"'{offlineUserDataJobResourceName}'.");
} else {
// Reuses the specified offline user data job.
offlineUserDataJobResourceName =
ResourceNames.OfflineUserDataJob(customerId, offlineUserDataJobId.Value);
}
AddOfflineUserDataJobOperationsRequest request =
new AddOfflineUserDataJobOperationsRequest()
{
ResourceName = offlineUserDataJobResourceName,
Operations = { BuildOfflineUserDataJobOperations() },
EnablePartialFailure = true,
};
// Issues a request to add the operations to the offline user data job. This example
// only adds a few operations, so it only sends one AddOfflineUserDataJobOperations
// request.
// If your application is adding a large number of operations, split the operations into
// batches and send multiple AddOfflineUserDataJobOperations requests for the SAME job.
// See https://developers.google.com/google-ads/api/docs/remarketing/audience-types/customer-match#customer_match_considerations
// and https://developers.google.com/google-ads/api/docs/best-practices/quotas#user_data
// for more information on the per-request limits.
AddOfflineUserDataJobOperationsResponse response2 =
service.AddOfflineUserDataJobOperations(request);
// Prints the status message if any partial failure error is returned.
// Note: The details of each partial failure error are not printed here,
// you can refer to the example HandlePartialFailure.cs to learn more.
if (response2.PartialFailureError != null)
{
// Extracts the partial failure from the response status.
GoogleAdsFailure partialFailure = response2.PartialFailure;
Console.WriteLine($"{partialFailure.Errors.Count} partial failure error(s) " +
$"occurred");
}
Console.WriteLine("The operations are added to the offline user data job.");
if (!runJob)
{
Console.WriteLine($"Not running offline user data job " +
"'{offlineUserDataJobResourceName}', as requested.");
return offlineUserDataJobResourceName;
}
// Issues an asynchronous request to run the offline user data job for executing
// all added operations.
Operation<Empty, OfflineUserDataJobMetadata> operationResponse =
service.RunOfflineUserDataJob(offlineUserDataJobResourceName);
Console.WriteLine("Asynchronous request to execute the added operations started.");
// Since offline user data jobs may take 24 hours or more to complete, it may not be
// practical to do operationResponse.PollUntilCompleted() to wait for the results.
// Instead, we save the offlineUserDataJobResourceName and use GoogleAdsService.Search
// to check for the job status periodically.
// In case you wish to follow the PollUntilCompleted or PollOnce approach, make sure
// you keep both operationResponse and service variables alive until the polling
// completes.
return offlineUserDataJobResourceName;
}
PHP
private static function addUsersToCustomerMatchUserList(
GoogleAdsClient $googleAdsClient,
int $customerId,
bool $runJob,
?string $userListResourceName,
?int $offlineUserDataJobId,
?int $adPersonalizationConsent,
?int $adUserDataConsent
) {
$offlineUserDataJobServiceClient =
$googleAdsClient->getOfflineUserDataJobServiceClient();
if (is_null($offlineUserDataJobId)) {
// Creates a new offline user data job.
$offlineUserDataJob = new OfflineUserDataJob([
'type' => OfflineUserDataJobType::CUSTOMER_MATCH_USER_LIST,
'customer_match_user_list_metadata' => new CustomerMatchUserListMetadata([
'user_list' => $userListResourceName
])
]);
// Adds consent information to the job if specified.
if (!empty($adPersonalizationConsent) || !empty($adUserDataConsent)) {
$consent = new Consent();
if (!empty($adPersonalizationConsent)) {
$consent->setAdPersonalization($adPersonalizationConsent);
}
if (!empty($adUserDataConsent)) {
$consent->setAdUserData($adUserDataConsent);
}
// Specifies whether user consent was obtained for the data you are uploading. See
// https://www.google.com/about/company/user-consent-policy for details.
$offlineUserDataJob->getCustomerMatchUserListMetadata()->setConsent($consent);
}
// Issues a request to create the offline user data job.
/** @var CreateOfflineUserDataJobResponse $createOfflineUserDataJobResponse */
$createOfflineUserDataJobResponse =
$offlineUserDataJobServiceClient->createOfflineUserDataJob(
CreateOfflineUserDataJobRequest::build($customerId, $offlineUserDataJob)
);
$offlineUserDataJobResourceName = $createOfflineUserDataJobResponse->getResourceName();
printf(
"Created an offline user data job with resource name: '%s'.%s",
$offlineUserDataJobResourceName,
PHP_EOL
);
} else {
// Reuses the specified offline user data job.
$offlineUserDataJobResourceName =
ResourceNames::forOfflineUserDataJob($customerId, $offlineUserDataJobId);
}
// Issues a request to add the operations to the offline user data job. This example
// only adds a few operations, so it only sends one AddOfflineUserDataJobOperations request.
// If your application is adding a large number of operations, split the operations into
// batches and send multiple AddOfflineUserDataJobOperations requests for the SAME job. See
// https://developers.google.com/google-ads/api/docs/remarketing/audience-types/customer-match#customer_match_considerations
// and https://developers.google.com/google-ads/api/docs/best-practices/quotas#user_data
// for more information on the per-request limits.
/** @var AddOfflineUserDataJobOperationsResponse $operationResponse */
$response = $offlineUserDataJobServiceClient->addOfflineUserDataJobOperations(
AddOfflineUserDataJobOperationsRequest::build(
$offlineUserDataJobResourceName,
self::buildOfflineUserDataJobOperations()
)->setEnablePartialFailure(true)
);
// Prints the status message if any partial failure error is returned.
// Note: The details of each partial failure error are not printed here, you can refer to
// the example HandlePartialFailure.php to learn more.
if ($response->hasPartialFailureError()) {
// Extracts the partial failure from the response status.
$partialFailure = GoogleAdsFailures::fromAny(
$response->getPartialFailureError()->getDetails()->getIterator()->current()
);
printf(
"%d partial failure error(s) occurred: %s.%s",
count($partialFailure->getErrors()),
$response->getPartialFailureError()->getMessage(),
PHP_EOL
);
} else {
print 'The operations are added to the offline user data job.' . PHP_EOL;
}
if ($runJob === false) {
printf(
"Not running offline user data job '%s', as requested.%s",
$offlineUserDataJobResourceName,
PHP_EOL
);
return;
}
// Issues an asynchronous request to run the offline user data job for executing all added
// operations. The result is OperationResponse. Visit the OperationResponse.php file for
// more details.
$offlineUserDataJobServiceClient->runOfflineUserDataJob(
RunOfflineUserDataJobRequest::build($offlineUserDataJobResourceName)
);
// Offline user data jobs may take 6 hours or more to complete, so instead of waiting
// for the job to complete, retrieves and displays the job status once. If the job is
// completed successfully, prints information about the user list. Otherwise, prints the
// query to use to check the job again later.
self::checkJobStatus($googleAdsClient, $customerId, $offlineUserDataJobResourceName);
}
Python
def add_users_to_customer_match_user_list(
client,
customer_id,
user_list_resource_name,
run_job,
offline_user_data_job_id,
ad_user_data_consent,
ad_personalization_consent,
):
"""Uses Customer Match to create and add users to a new user list.
Args:
client: The Google Ads client.
customer_id: The ID for the customer that owns the user list.
user_list_resource_name: The resource name of the user list to which to
add users.
run_job: If true, runs the OfflineUserDataJob after adding operations.
Otherwise, only adds operations to the job.
offline_user_data_job_id: ID of an existing OfflineUserDataJob in the
PENDING state. If None, a new job is created.
ad_user_data_consent: The consent status for ad user data for all
members in the job.
ad_personalization_consent: The personalization consent status for ad
user data for all members in the job.
"""
# Creates the OfflineUserDataJobService client.
offline_user_data_job_service_client = client.get_service(
"OfflineUserDataJobService"
)
if offline_user_data_job_id:
# Reuses the specified offline user data job.
offline_user_data_job_resource_name = (
offline_user_data_job_service_client.offline_user_data_job_path(
customer_id, offline_user_data_job_id
)
)
else:
# Creates a new offline user data job.
offline_user_data_job = client.get_type("OfflineUserDataJob")
offline_user_data_job.type_ = (
client.enums.OfflineUserDataJobTypeEnum.CUSTOMER_MATCH_USER_LIST
)
offline_user_data_job.customer_match_user_list_metadata.user_list = (
user_list_resource_name
)
# Specifies whether user consent was obtained for the data you are
# uploading. For more details, see:
# https://www.google.com/about/company/user-consent-policy
if ad_user_data_consent:
offline_user_data_job.customer_match_user_list_metadata.consent.ad_user_data = client.enums.ConsentStatusEnum[
ad_user_data_consent
]
if ad_personalization_consent:
offline_user_data_job.customer_match_user_list_metadata.consent.ad_personalization = client.enums.ConsentStatusEnum[
ad_personalization_consent
]
# Issues a request to create an offline user data job.
create_offline_user_data_job_response = (
offline_user_data_job_service_client.create_offline_user_data_job(
customer_id=customer_id, job=offline_user_data_job
)
)
offline_user_data_job_resource_name = (
create_offline_user_data_job_response.resource_name
)
print(
"Created an offline user data job with resource name: "
f"'{offline_user_data_job_resource_name}'."
)
# Issues a request to add the operations to the offline user data job.
# Best Practice: This example only adds a few operations, so it only sends
# one AddOfflineUserDataJobOperations request. If your application is adding
# a large number of operations, split the operations into batches and send
# multiple AddOfflineUserDataJobOperations requests for the SAME job. See
# https://developers.google.com/google-ads/api/docs/remarketing/audience-types/customer-match#customer_match_considerations
# and https://developers.google.com/google-ads/api/docs/best-practices/quotas#user_data
# for more information on the per-request limits.
request = client.get_type("AddOfflineUserDataJobOperationsRequest")
request.resource_name = offline_user_data_job_resource_name
request.operations = build_offline_user_data_job_operations(client)
request.enable_partial_failure = True
# Issues a request to add the operations to the offline user data job.
response = offline_user_data_job_service_client.add_offline_user_data_job_operations(
request=request
)
# Prints the status message if any partial failure error is returned.
# Note: the details of each partial failure error are not printed here.
# Refer to the error_handling/handle_partial_failure.py example to learn
# more.
# Extracts the partial failure from the response status.
partial_failure = getattr(response, "partial_failure_error", None)
if getattr(partial_failure, "code", None) != 0:
error_details = getattr(partial_failure, "details", [])
for error_detail in error_details:
failure_message = client.get_type("GoogleAdsFailure")
# Retrieve the class definition of the GoogleAdsFailure instance
# in order to use the "deserialize" class method to parse the
# error_detail string into a protobuf message object.
failure_object = type(failure_message).deserialize(
error_detail.value
)
for error in failure_object.errors:
print(
"A partial failure at index "
f"{error.location.field_path_elements[0].index} occurred.\n"
f"Error message: {error.message}\n"
f"Error code: {error.error_code}"
)
print("The operations are added to the offline user data job.")
if not run_job:
print(
"Not running offline user data job "
f"'{offline_user_data_job_resource_name}', as requested."
)
return
# Issues a request to run the offline user data job for executing all
# added operations.
offline_user_data_job_service_client.run_offline_user_data_job(
resource_name=offline_user_data_job_resource_name
)
# Retrieves and displays the job status.
check_job_status(client, customer_id, offline_user_data_job_resource_name)
Ruby
def add_users_to_customer_match_user_list(client, customer_id, run_job, user_list, job_id, ad_user_data_consent, ad_personalization_consent)
offline_user_data_service = client.service.offline_user_data_job
job_name = if job_id.nil?
# Creates the offline user data job.
offline_user_data_job = client.resource.offline_user_data_job do |job|
job.type = :CUSTOMER_MATCH_USER_LIST
job.customer_match_user_list_metadata =
client.resource.customer_match_user_list_metadata do |m|
m.user_list = user_list
if !ad_user_data_consent.nil? || !ad_personalization_consent.nil?
m.consent = client.resource.consent do |c|
# Specifies whether user consent was obtained for the data you are
# uploading. For more details, see:
# https://www.google.com/about/company/user-consent-policy
unless ad_user_data_consent.nil?
c.ad_user_data = ad_user_data_consent
end
unless ad_personalization_consent.nil?
c.ad_personalization = ad_personalization_consent
end
end
end
end
end
# Issues a request to create the offline user data job.
response = offline_user_data_service.create_offline_user_data_job(
customer_id: customer_id,
job: offline_user_data_job,
)
offline_user_data_job_resource_name = response.resource_name
puts "Created an offline user data job with resource name: " \
"#{offline_user_data_job_resource_name}"
offline_user_data_job_resource_name
else
client.path.offline_user_data_job(customer_id, job_id)
end
# Issues a request to add the operations to the offline user data job. This
# example only adds a few operations, so it only sends one
# AddOfflineUserDataJobOperations request. If your application is adding a
# large number of operations, split the operations into batches and send
# multiple AddOfflineUserDataJobOperations requests for the SAME job. See
# https://developers.google.com/google-ads/api/docs/remarketing/audience-types/customer-match#customer_match_considerations
# and https://developers.google.com/google-ads/api/docs/best-practices/quotas#user_data
# for more information on the per-request limits.
response = offline_user_data_service.add_offline_user_data_job_operations(
resource_name: offline_user_data_job_resource_name,
enable_partial_failure: true,
operations: build_offline_user_data_job_operations(client),
)
# Prints errors if any partial failure error is returned.
if response.partial_failure_error
failures = client.decode_partial_failure_error(response.partial_failure_error)
failures.each do |failure|
failure.errors.each do |error|
human_readable_error_path = error
.location
.field_path_elements
.map { |location_info|
if location_info.index
"#{location_info.field_name}[#{location_info.index}]"
else
"#{location_info.field_name}"
end
}.join(" > ")
errmsg = "error occured while adding operations " \
"#{human_readable_error_path}" \
" with value: #{error.trigger.string_value}" \
" because #{error.message.downcase}"
puts errmsg
end
end
end
puts "The operations are added to the offline user data job."
unless run_job
puts "Not running offline user data job #{job_name}, as requested."
return
end
# Issues an asynchronous request to run the offline user data job
# for executing all added operations.
response = offline_user_data_service.run_offline_user_data_job(
resource_name: offline_user_data_job_resource_name
)
puts "Asynchronous request to execute the added operations started."
puts "Waiting until operation completes."
# Offline user data jobs may take 6 hours or more to complete, so instead of
# waiting for the job to complete, retrieves and displays the job status
# once. If the job is completed successfully, prints information about the
# user list. Otherwise, prints the query to use to check the job again later.
check_job_status(
client,
customer_id,
offline_user_data_job_resource_name,
)
end
Perl
sub add_users_to_customer_match_user_list {
my ($api_client, $customer_id, $run_job, $user_list_resource_name,
$offline_user_data_job_id, $ad_personalization_consent,
$ad_user_data_consent)
= @_;
my $offline_user_data_job_service = $api_client->OfflineUserDataJobService();
my $offline_user_data_job_resource_name = undef;
if (!defined $offline_user_data_job_id) {
# Create a new offline user data job.
my $offline_user_data_job =
Google::Ads::GoogleAds::V17::Resources::OfflineUserDataJob->new({
type => CUSTOMER_MATCH_USER_LIST,
customerMatchUserListMetadata =>
Google::Ads::GoogleAds::V17::Common::CustomerMatchUserListMetadata->
new({
userList => $user_list_resource_name
})});
# Add consent information to the job if specified.
if ($ad_personalization_consent or $ad_user_data_consent) {
my $consent = Google::Ads::GoogleAds::V17::Common::Consent->new({});
if ($ad_personalization_consent) {
$consent->{adPersonalization} = $ad_personalization_consent;
}
if ($ad_user_data_consent) {
$consent->{adUserData} = $ad_user_data_consent;
}
# Specify whether user consent was obtained for the data you are uploading.
# See https://www.google.com/about/company/user-consent-policy for details.
$offline_user_data_job->{customerMatchUserListMetadata}{consent} =
$consent;
}
# Issue a request to create the offline user data job.
my $create_offline_user_data_job_response =
$offline_user_data_job_service->create({
customerId => $customer_id,
job => $offline_user_data_job
});
$offline_user_data_job_resource_name =
$create_offline_user_data_job_response->{resourceName};
printf
"Created an offline user data job with resource name: '%s'.\n",
$offline_user_data_job_resource_name;
} else {
# Reuse the specified offline user data job.
$offline_user_data_job_resource_name =
Google::Ads::GoogleAds::V17::Utils::ResourceNames::offline_user_data_job(
$customer_id, $offline_user_data_job_id);
}
# Issue a request to add the operations to the offline user data job.
# This example only adds a few operations, so it only sends one AddOfflineUserDataJobOperations
# request. If your application is adding a large number of operations, split
# the operations into batches and send multiple AddOfflineUserDataJobOperations
# requests for the SAME job. See
# https://developers.google.com/google-ads/api/docs/remarketing/audience-types/customer-match#customer_match_considerations
# and https://developers.google.com/google-ads/api/docs/best-practices/quotas#user_data
# for more information on the per-request limits.
my $user_data_job_operations = build_offline_user_data_job_operations();
my $response = $offline_user_data_job_service->add_operations(
{
resourceName => $offline_user_data_job_resource_name,
enablePartialFailure => "true",
operations => $user_data_job_operations
});
# Print the status message if any partial failure error is returned.
# Note: The details of each partial failure error are not printed here, you can
# refer to the example handle_partial_failure.pl to learn more.
if ($response->{partialFailureError}) {
# Extract the partial failure from the response status.
my $partial_failure = $response->{partialFailureError}{details}[0];
printf "Encountered %d partial failure errors while adding %d operations " .
"to the offline user data job: '%s'. Only the successfully added " .
"operations will be executed when the job runs.\n",
scalar @{$partial_failure->{errors}}, scalar @$user_data_job_operations,
$response->{partialFailureError}{message};
} else {
printf "Successfully added %d operations to the offline user data job.\n",
scalar @$user_data_job_operations;
}
if (!defined $run_job) {
print
"Not running offline user data job $offline_user_data_job_resource_name, as requested.\n";
return;
}
# Issue an asynchronous request to run the offline user data job for executing
# all added operations.
my $operation_response = $offline_user_data_job_service->run({
resourceName => $offline_user_data_job_resource_name
});
# Offline user data jobs may take 6 hours or more to complete, so instead of waiting
# for the job to complete, this example retrieves and displays the job status once.
# If the job is completed successfully, it prints information about the user list.
# Otherwise, it prints, the query to use to check the job status again later.
check_job_status($api_client, $customer_id,
$offline_user_data_job_resource_name);
}
식별자를 사용하여 개별 사용자 삭제하기
개별 사용자를 삭제하려면 다음 단계를 따르세요.
remove속성을 설정하고OfflineUserDataJobOperationUserData객체와 같음UserIdentifier객체를 하나 이상 추가합니다. 반복된user_identifiers[]필드를 확인합니다. 단일 사용자 식별자를 사용하면 사용자와 일치하는 식별자가 둘 이상 제출된 경우
목록에서 모든 데이터를 한 번에 삭제
목록에서 모든 사용자를 삭제하려면 remove_all을(를) true(으)로 설정합니다.
OfflineUserDataJobOperation 이후
발행
RunOfflineUserDataJob
remove_all 작업과 연결된 리소스 이름으로 요청을 전송합니다.
remove_all 작업이 포함된 경우 첫 번째 작업이어야 합니다.
작업을 수행합니다 그렇지 않은 경우 작업을 실행하면
INVALID_OPERATION_ORDER 드림
오류가 발생했습니다. 사용자 목록의 구성원을 새 구성원으로 완전히 바꾸려면 다음을 정렬합니다.
AddOfflineUserDataJobOperationsRequest의 작업을 이 순서대로 반환합니다.
다음에서
remove_all를true로 설정:OfflineUserDataJobOperation각 새 멤버에
create작업을 추가하고UserData를 설정합니다.OfflineUserDataJobOperation
remove_all 작업은 매시간 실행되며 최대 24시간 동안 실행될 수 있습니다.
고객 목록 새로고침 추천
다음 유형의 추천을 가져올 수 있습니다.
REFRESH_CUSTOMER_MATCH_LIST 드림
를 사용하여 한동안 업데이트되지 않은 고객 목록을 식별합니다. 이것은
사용자에게 광고를 게재할 수 있게 해주는 서드 파티 광고주인 경우 특히
고객 목록을 관리합니다.
권장사항 사용에 대한 자세한 내용은 최적화 점수 및 추천 가이드
목록 삭제
사용
UserListService.mutate_user_lists 드림
remove 작업을 제출하는 메서드
를 사용하세요.
UserDataService로 목록 업데이트
UserDataService의 한도는 10개입니다.
작업 및 요청당 총 100개의 user_identifiers이므로
를 참조하세요. 예를 들어 각 UserData 객체에
hashed_email UserIdentifier 및 추가 UserIdentifier
hashed_phone_number인 경우 요청에 UserData를 최대 50개까지 포함할 수 있습니다.
객체입니다.
UserDataService에는 UploadUserData 메서드가 포함되어 있으며, 이 메서드는
UploadUserDataRequest 또한
customer_id: UploadUserDataRequest는 작업 목록을 허용함
을 사용하여 연락처와 필수 입력란을 만듭니다.
customer_match_user_list_metadata - 리소스 이름으로 채워짐
선택하는 것입니다.
먼저 다음을 채우는 UploadUserDataRequest 인스턴스를 만듭니다.
customer_id 및 customer_match_user_list_metadata:
자바
// Creates a request to add user data operations to the user list based on email addresses.
String userListResourceName = ResourceNames.userList(customerId, userListId);
UploadUserDataRequest.Builder uploadUserDataRequest =
UploadUserDataRequest.newBuilder()
.setCustomerId(String.valueOf(customerId))
.setCustomerMatchUserListMetadata(
CustomerMatchUserListMetadata.newBuilder()
.setUserList(StringValue.of(userListResourceName))
.build());
사용자 연락처 정보를 업로드하려면 CrmBasedUserListInfo.upload_key_type을(를) 설정하세요.
CONTACT_INFO에게 전송합니다.
먼저 UploadUserDataRequest 객체에 작업을 추가합니다. 각 작업
UserData로 채워진 create 필드를 포함합니다.
하나 이상의 UserIdentifier를 보유하는 객체
인스턴스 각 UserIdentifier에는 식별 정보가 포함되어 있습니다.
여러 유형 중 하나일 수 있으며, 각 유형은 아래에 설명되어 있습니다.
고객 이메일 주소를 업로드하려면 새 이메일 주소를 만드세요.
UserDataOperation를 선택하고 만들기 채우기
필드를 UserData 객체로 변환합니다. UserData 객체는
user_identifiers hashed_email 필드를 고객 이메일로 채웁니다.
있습니다.
자바
ImmutableList<String> EMAILS =
ImmutableList.of("client1@example.com", "client2@example.com", " Client3@example.com ");
// Hash normalized email addresses based on SHA-256 hashing algorithm.
List<UserDataOperation> userDataOperations = new ArrayList<>(EMAILS.size());
for (String email : EMAILS) {
UserDataOperation userDataOperation =
UserDataOperation.newBuilder()
.setCreate(
UserData.newBuilder()
.addUserIdentifiers(
UserIdentifier.newBuilder()
.setHashedEmail(StringValue.of(toSHA256String(email)))
.build())
.build())
.build();
userDataOperations.add(userDataOperation);
}
uploadUserDataRequest.addAllOperations(userDataOperations);
사용자(address_info)를 업로드하는 것은 사용자 이메일 주소를 업로드하는 것과 비슷합니다.
그러나 hashed_email를 전달하는 대신 address_info 필드를 채웁니다.
OfflineUserAddressInfo 객체 사용
사용자의 first_name, last_name, country_code 및
postal_code 이메일 주소와 마찬가지로 first_name 및 last_name이(가) 고려됩니다.
업로드하기 전에 해싱해야 합니다.
자바
String firstName = "Alex";
String lastName = "Quinn";
String countryCode = "US";
String postalCode = "94045";
UserIdentifier userIdentifierWithAddress =
UserIdentifier.newBuilder()
.setAddressInfo(
OfflineUserAddressInfo.newBuilder()
// First and last name must be normalized and hashed.
.setHashedFirstName(
StringValue.of(toSHA256String(firstName)))
.setHashedLastName(StringValue.of(toSHA256String(lastName)))
// Country code and zip code are sent in plaintext.
.setCountryCode(StringValue.of(countryCode))
.setPostalCode(StringValue.of(postalCode))
.build())
.build();
UserDataOperation userDataOperation =
UserDataOperation.newBuilder()
.setCreate(
UserData.newBuilder()
.addUserIdentifiers(userIdentifierWithAddress)
.build())
.build();
uploadUserDataRequest.addOperations(userDataOperation);
UploadUserDataRequest 인스턴스에 작업을 추가한 후
요청을 보낼 UserDataServiceClient의 uploadUserData 메서드
Google Ads API 서버에 연결할 수 있습니다. 다음 명령어로 요청이 성공했는지 확인할 수 있습니다.
응답 객체의 작업 개수 및 업로드 시간 명심하세요
목록에 구성원이 채워지는 데 몇 시간이 걸릴 수 있습니다.
자바
// Creates the user data service client.
try (UserDataServiceClient userDataServiceClient =
googleAdsClient.getLatestVersion().createUserDataServiceClient()) {
// Add operations to the user list based on the user data type.
UploadUserDataResponse response =
userDataServiceClient.uploadUserData(uploadUserDataRequest.build());
// Displays the results.
// Reminder: it may take several hours for the list to be populated with members.
System.out.printf(
"Received %d operations at %s",
response.getReceivedOperationsCount().getValue(),
response.getUploadDateTime().getValue());
}
목록 타겟팅 수준 전환
예를 들어 광고 그룹에서 캠페인 수준 타겟팅으로 변경하는 경우 타겟팅 수준 전환에 관해 문의하세요. 가이드를 확인하세요.
목록 실적 검토
잠재고객 세그먼트에 대한 실적 데이터를 수집하려면 검색을 실행하세요.
ad_group_audience_view에 대한 요청
또는 campaign_audience_view 리소스.
예를 들어 conversions 또는 cost_per_conversion를 확인하여
잠재고객 세그먼트 타겟팅이 실제로
그에 따라 입찰가 조정을 조정하세요.
SELECT
ad_group_criterion.criterion_id,
metrics.conversions,
metrics.cost_per_conversion
FROM ad_group_audience_view
트래픽을 기반으로 입찰가를 최적화하기 전에 최소 2주간 기다리는 것이 좋습니다. 계정에 연결할 수 있습니다