Einladungen zum Nutzerzugriff verwalten

Als Google Ads-Administrator können Sie Einladungen zum Zugriff auf ein Google Ads-Konto verwalten.

Nutzer einladen

Sie können einem neuen Nutzer im Rahmen der Verwaltung des Zugriffs auf ein Google Ads-Konto eine E-Mail-Einladung senden. Dazu wird ein neues CustomerUserAccessInvitation mit der Methode MutateCustomerUserAccessInvitation des CustomerUserAccessInvitationService erstellt. Die E‑Mail-Einladung muss manuell von dem Nutzer angenommen werden, der sie erhalten hat. Die Einladung kann auch mit einer alternativen E‑Mail-Adresse angenommen werden. Es kann bis zu 24 Stunden dauern, bis sich der Status nach Annahme der Einladung von „Ausstehend“ ändert.

Dieses Code-Snippet zeigt, wie eine Einladung gesendet wird:

Java

// Constructs an access invitation.
CustomerUserAccessInvitation invitation =
    CustomerUserAccessInvitation.newBuilder()
        .setEmailAddress(emailAddress)
        .setAccessRole(accessRole)
        .build();

// Constructs an operation to send the invitation.
CustomerUserAccessInvitationOperation operation =
    CustomerUserAccessInvitationOperation.newBuilder().setCreate(invitation).build();

// Creates a CustomerUserAccessInvitationServiceClient.
try (CustomerUserAccessInvitationServiceClient client =
    googleAdsClient.getLatestVersion().createCustomerUserAccessInvitationServiceClient()) {
  // Issues the request.
  MutateCustomerUserAccessInvitationResponse response =
      client.mutateCustomerUserAccessInvitation(String.valueOf(customerId), operation);

  // Prints some information about the result.
  System.out.printf(
      "Customer user access invitation was sent for customerId = "
          + "%d to email address = '%s' and access role = '%s'. The invitation resource "
          + "name is '%s'.%n",
      customerId, emailAddress, accessRole, response.getResult().getResourceName());
}
InviteUserWithAccessRole.java
      

C#

MutateCustomerUserAccessInvitationRequest invitationRequest =
    new MutateCustomerUserAccessInvitationRequest()
    {
        CustomerId = customerId.ToString(),
        Operation = new CustomerUserAccessInvitationOperation()
        {
            Create = new CustomerUserAccessInvitation()
            {
                EmailAddress = emailAddress,
                AccessRole = accessRole
            },
        }
    };
try
{
    var response = service.MutateCustomerUserAccessInvitation(invitationRequest);

    Console.WriteLine("Customer user access invitation was sent for customerId = " +
        "{0} to email address = {1} and access role = {2}. The invitation resource " +
        "name is {3}.", customerId, emailAddress, accessRole,
        response.Result.ResourceName);
}
catch (GoogleAdsException e)
{
    Console.WriteLine("Failure:");
    Console.WriteLine($"Message: {e.Message}");
    Console.WriteLine($"Failure: {e.Failure}");
    Console.WriteLine($"Request ID: {e.RequestId}");
    throw;
}
InviteUserWithAccessRole.cs
      

PHP

// Creates a customer user access invitation.
$customerUserAccessInvitation = new CustomerUserAccessInvitation([
    'email_address' =>  $emailAddress,
    'access_role' => AccessRole::value($accessRole)
]);

// Creates a customer user access invitation operation.
$customerUserAccessInvitationOperation = new CustomerUserAccessInvitationOperation();
$customerUserAccessInvitationOperation->setCreate($customerUserAccessInvitation);

// Issues a mutate request to send the customer user access invitation and prints its
// information.
$customerUserAccessInvitationServiceClient =
    $googleAdsClient->getCustomerUserAccessInvitationServiceClient();
$response = $customerUserAccessInvitationServiceClient->mutateCustomerUserAccessInvitation(
    MutateCustomerUserAccessInvitationRequest::build(
        $customerId,
        $customerUserAccessInvitationOperation
    )
);
printf(
    "Customer user access invitation with resource name '%s' was sent from customer "
    . "ID %d to email address '%s' with access role '%s'.%s",
    $response->getResult()->getResourceName(),
    $customerId,
    $emailAddress,
    $accessRole,
    PHP_EOL
);
InviteUserWithAccessRole.php
      

Python

invitation_operation: CustomerUserAccessInvitationOperation = (
    client.get_type("CustomerUserAccessInvitationOperation")
)
invitation: CustomerUserAccessInvitation = invitation_operation.create
invitation.email_address = email_address
# The access_role field in the CustomerUserAccessInvitation message expects
# an AccessRoleEnum value (which is an int).
invitation.access_role = client.enums.AccessRoleEnum[access_role].value

response: MutateCustomerUserAccessInvitationResponse = (
    service.mutate_customer_user_access_invitation(
        customer_id=customer_id, operation=invitation_operation
    )
)
print(
    "Customer user access invitation was sent for "
    f"customer ID: '{customer_id}', "
    f"email address {email_address}, and "
    f"access role {access_role}. The invitation resource name is: "
    f"{response.result.resource_name}"
)
invite_user_with_access_role.py
      

Ruby

operation = client.operation.create_resource.customer_user_access_invitation do |inv|
  inv.email_address = email_address
  inv.access_role = access_role
end

# Issues a mutate request to get the response.
response = client.service.customer_user_access_invitation.mutate_customer_user_access_invitation(
  customer_id: customer_id,
  operation: operation,
)

# Prints out information of the created invitation.
puts "Customer user access invitation was sent for customerId = #{customer_id} " \
  "email address = '#{email_address}', " \
  "access role = '#{access_role}'."
invite_user_with_access_role.rb
      

Perl

sub invite_user_with_access_role {
  my ($api_client, $customer_id, $email_address, $access_role) = @_;

  # Create the user access invitation.
  my $user_access_invitation =
    Google::Ads::GoogleAds::V21::Resources::CustomerUserAccessInvitation->new({
      emailAddress => $email_address,
      accessRole   => $access_role
    });

  # Create the user access invitation operation.
  my $invitation_operation =
    Google::Ads::GoogleAds::V21::Services::CustomerUserAccessInvitationService::CustomerUserAccessInvitationOperation
    ->new({create => $user_access_invitation});

  # Send the user access invitation.
  my $invitation_response =
    $api_client->CustomerUserAccessInvitationService()->mutate({
      customerId => $customer_id,
      operation  => $invitation_operation
    });

  printf "Customer user access invitation was sent for customerId = %d " .
    "to email address = '%s' and access role = '%s'. " .
    "The invitation resource name is '%s'.\n",
    $customer_id, $email_address, $access_role,
    $invitation_response->{result}{resourceName};

  return 1;
}
invite_user_with_access_role.pl
      

curl

# This code example sends an invitation email to a user.
#
# The invitation is to manage a customer account with a desired access role.
#
# Variables:
#   API_VERSION,
#   CUSTOMER_ID,
#   DEVELOPER_TOKEN,
#   MANAGER_CUSTOMER_ID,
#   OAUTH2_ACCESS_TOKEN:
#     See https://developers.google.com/google-ads/api/rest/auth#request_headers
#     for details.
#
#   EMAIL_ADDRESS: The email address of the user to invite.
curl -f --request POST \
"https://googleads.googleapis.com/v${API_VERSION}/customers/${CUSTOMER_ID}/customerUserAccessInvitations:mutate" \
--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
{
  "operation": {
    "create": {
      "emailAddress": "${EMAIL_ADDRESS}",
      "accessRole": "ADMIN"
    }
  }
}
EOF
invite_user_with_access_role.sh
      

Einladungen zurücknehmen

Sie können eine Einladung widerrufen, indem Sie ein CustomerUserAccessInvitation mit der Methode MutateCustomerUserAccessInvitation des CustomerUserAccessInvitationService entfernen.

Nutzereinladungen abrufen

Sie können die Liste der ausstehenden Einladungen abrufen, indem Sie eine Google Ads Query Language-Anweisung erstellen, um alle CustomerUserAccessInvitation-Entitäten abzufragen, die einer Kunden-ID zugeordnet sind. Hier sehen Sie eine typische Anfrage:

SELECT
    customer_user_access_invitation.invitation_id,
    customer_user_access_invitation.email_address,
    customer_user_access_invitation.access_role,
    customer_user_access_invitation.invitation_status,
    customer_user_access_invitation.creation_date_time
FROM
    customer_user_access_invitation

Sie können zusätzliche Filterbedingungen hinzufügen, um Teilmengen von Einladungen abzurufen. Ein häufiger Anwendungsfall ist beispielsweise das Abrufen der Liste ausstehender Einladungen für Nutzer. Dazu können Sie nach customer_user_access_invitation.invitation_status = PENDING filtern: