Kontobudgets

Mit Kontobudgets können Sie festlegen, wie viel Geld ein Konto in einem bestimmten Zeitraum ausgeben kann. Dazu werden Budgeteigenschaften wie Ausgabenlimit, Startzeit und Endzeit definiert. Sie müssen auf eine der Abrechnungseinrichtungen des Kontos verweisen, um anzugeben, welches Zahlungskonto belastet werden soll. Sie können die AccountBudget in der Google Ads API erstellen, aktualisieren und entfernen, indem Sie AccountBudgetProposal-Objekte senden.

AccountBudget -Objekte stellen das Endergebnis der Anwendung von Vorschlägen dar. Nachdem ein Vorschlag genehmigt wurde, führt er (ggf. nach Anpassungen) zur Erstellung eines neuen Kontobudgets oder zur Aktualisierung eines bestehenden. Das hängt vom proposal_type ab, der in der Anfrage angegeben ist.

AccountBudgetProposalType Beschreibung
CREATE Erstellt ein neues Kontobudget, das vor der Verwendung genehmigt werden muss.
UPDATE Ändert ein vorhandenes Kontobudget.
END Legt die Endzeit eines Kontobudgets auf die aktuelle Zeit fest.
REMOVE Entfernt ein Kontobudget vor seiner Startzeit.

In den folgenden Abschnitten wird das Verhalten der einzelnen Vorschlagstypen beschrieben.

Vorschlag für ein Kontobudget erstellen

Wenn Sie ein neues Kontobudget erstellen, können Sie die Ausgaben eines Kunden kontrollieren. Verwenden Sie AccountBudgetProposalService, um ein neues AccountBudgetProposal-Objekt zu erstellen. Setzen Sie proposal_type auf CREATE, um anzugeben , dass ein neues Budget erstellt werden soll. Weitere Vorgänge finden Sie im Abschnitt zur Verwaltung in diesem Leitfaden.

Verwenden Sie eine Abrechnungseinrichtung mit einem Zahlungskonto, für das Sie Schreibzugriff haben. Weitere Informationen finden Sie im Leitfaden zur Abrechnungseinrichtung für Details.

Im folgenden Beispiel wird gezeigt, wie Sie einen neuen Budgetvorschlag erstellen.

Java

private void runExample(GoogleAdsClient googleAdsClient, long customerId, long billingSetupId) {
  // Creates an AccountBudgetProposal. This will be reviewed offline by Google Ads, and if
  // approved will become an AccountBudget.
  AccountBudgetProposal proposal =
      AccountBudgetProposal.newBuilder()
          .setBillingSetup(ResourceNames.billingSetup(customerId, billingSetupId))
          .setProposalType(AccountBudgetProposalType.CREATE)
          .setProposedName("Account Budget (example)")

          // Specifies the account budget starts immediately.
          .setProposedStartTimeType(TimeType.NOW)
          // Alternatively you can specify a specific start time. Refer to the
          // AccountBudgetProposal
          // resource documentation for allowed formats.
          //
          // .setProposedStartDateTime("2020-01-02 03:04:05")

          // Specifies that the budget runs forever.
          .setProposedEndTimeType(TimeType.FOREVER)
          // Alternatively you can specify a specific end time. Allowed formats are as above.
          // .setProposedEndDateTime("2021-02-03 04:05:06")

          // Optional: sets notes for the budget. These are free text and do not effect budget
          // delivery.
          // .setProposedNotes("Received prepayment of $0.01")

          // Sets the spending limit to 0.01, measured in the Google Ads account currency.
          .setProposedSpendingLimitMicros(10_000)

          // Optional: sets PO number for record keeping. This value is at the user's
          // discretion, and has no effect on Google Billing & Payments.
          // .setProposedPurchaseOrderNumber("PO number 12345")
          .build();

  // Creates an operation which will add the new AccountBudgetProposal.
  AccountBudgetProposalOperation operation =
      AccountBudgetProposalOperation.newBuilder().setCreate(proposal).build();

  try (AccountBudgetProposalServiceClient accountBudgetProposalServiceClient =
      googleAdsClient.getLatestVersion().createAccountBudgetProposalServiceClient()) {
    // Sends the request to the Account Budget Proposal Service.
    MutateAccountBudgetProposalResponse response =
        accountBudgetProposalServiceClient.mutateAccountBudgetProposal(
            String.valueOf(customerId), operation);

    System.out.printf(
        "Account budget proposal created: %s.%n", response.getResult().getResourceName());
  }
}

C#

public void Run(GoogleAdsClient client, long customerId, long billingSetupId)
{
    // Get the AccountBudgetProposalServiceClient.
    AccountBudgetProposalServiceClient proposalService =
        client.GetService(Services.V25.AccountBudgetProposalService);

    // Create an AccountBudgetProposal. The proposal will be reviewed offline by Google Ads,
    // and if approved will become an AccountBudget.
    AccountBudgetProposal proposal = new AccountBudgetProposal()
    {
        BillingSetup = ResourceNames.BillingSetup(customerId, billingSetupId),
        ProposalType = AccountBudgetProposalType.Create,
        ProposedName = "Account Budget (example)",

        // Specify the account budget starts immediately
        ProposedStartTimeType = TimeType.Now,
        // Alternatively, you can specify a specific start time. Refer to the
        // AccountBudgetProposal resource documentation for allowed formats.
        //
        //ProposedStartDateTime = "2020-01-02 03:04:05",

        // Specify that the budget runs forever.
        ProposedEndTimeType = TimeType.Forever,
        // Alternatively you can specify a specific end time. Allowed formats are as above.
        //ProposedEndDateTime = "2021-02-03 04:05:06",

        // Optional: set notes for the budget. These are free text and do not effect budget
        // delivery.
        //ProposedNotes = "Received prepayment of $0.01",

        // Set the spending limit to 0.01, measured in the Google Ads account currency.
        ProposedSpendingLimitMicros = 10_000

        // Optional: set PO number for record keeping. This value is at the user's
        // discretion, and has no effect on Google Billing & Payments.
        //ProposedPurchaseOrderNumber = "PO number 12345"
    };

    // Create an operation which will add the new AccountBudgetProposal
    AccountBudgetProposalOperation operation = new AccountBudgetProposalOperation()
    {
        Create = proposal
    };

    try
    {
        // Send the request to the Account Budget Proposal Service.
        MutateAccountBudgetProposalResponse response = proposalService.
            MutateAccountBudgetProposal(customerId.ToString(), operation);

        // Display the results.
        Console.WriteLine($"Account budget proposal '{response.Result.ResourceName}' " +
            "was created.");
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    int $billingSetupId
) {
    // Constructs an account budget proposal.
    $accountBudgetProposal = new AccountBudgetProposal([
        'billing_setup' => ResourceNames::forBillingSetup($customerId, $billingSetupId),
        'proposal_type' => AccountBudgetProposalType::CREATE,
        'proposed_name' => 'Account Budget (example)',
        // Specifies the account budget starts immediately.
        'proposed_start_time_type' => TimeType::NOW,
        // Alternatively you can specify a specific start time. Refer to the
        // AccountBudgetProposal class for allowed formats.
        //
        // 'proposed_start_date_time' => '2020-01-02 03:04:05',

        // Specify that the budget runs forever.
        'proposed_end_time_type' => TimeType::FOREVER,
        // Alternatively you can specify a specific end time. Allowed formats are as above.
        // 'proposed_end_date_time' => '2021-02-03 04:05:06',

        // Optional: set notes for the budget. These are free text and do not effect budget
        // delivery.
        // 'proposed_notes' => 'Received prepayment of $0.01',

        // Optional: set PO number for record keeping. This value is at the user's
        // discretion, and has no effect on Google Billing & Payments.
        // 'proposed_purchase_order_number' => 'PO number 12345',

        // Set the spending limit to 0.01, measured in the Google Ads account currency.
        'proposed_spending_limit_micros' => 10000
    ]);

    $accountBudgetProposalOperation = new AccountBudgetProposalOperation();
    $accountBudgetProposalOperation->setCreate($accountBudgetProposal);

    // Issues a mutate request to add the account budget proposal.
    $accountBudgetProposalServiceClient =
        $googleAdsClient->getAccountBudgetProposalServiceClient();
    $response = $accountBudgetProposalServiceClient->mutateAccountBudgetProposal(
        MutateAccountBudgetProposalRequest::build($customerId, $accountBudgetProposalOperation)
    );

    printf(
        "Added an account budget proposal with resource name '%s'.%s",
        $response->getResult()->getResourceName(),
        PHP_EOL
    );
}

Python

def main(client: GoogleAdsClient, customer_id: str, billing_setup_id: str):
    account_budget_proposal_service = client.get_service(
        "AccountBudgetProposalService"
    )
    billing_setup_service = client.get_service("BillingSetupService")

    account_budget_proposal_operation = client.get_type(
        "AccountBudgetProposalOperation"
    )
    proposal = account_budget_proposal_operation.create

    proposal.proposal_type = client.enums.AccountBudgetProposalTypeEnum.CREATE
    proposal.billing_setup = billing_setup_service.billing_setup_path(
        customer_id, billing_setup_id
    )
    proposal.proposed_name = "Account Budget Proposal (example)"

    # Specify the account budget starts immediately
    proposal.proposed_start_time_type = client.enums.TimeTypeEnum.NOW
    # Alternatively you can specify a specific start time. Refer to the
    # AccountBudgetProposal resource documentation for allowed formats.
    #
    # proposal.proposed_start_date_time = '2020-01-02 03:04:05'

    # Specify that the budget runs forever
    proposal.proposed_end_time_type = client.enums.TimeTypeEnum.FOREVER
    # Alternatively you can specify a specific end time. Allowed formats are as
    # above.
    #
    # proposal.proposed_end_date_time = '2021-01-02 03:04:05'

    # Optional: set notes for the budget. These are free text and do not effect
    # budget delivery.
    #
    # proposal.proposed_notes = 'Received prepayment of $0.01'
    proposal.proposed_spending_limit_micros = 10000

    account_budget_proposal_response = (
        account_budget_proposal_service.mutate_account_budget_proposal(
            customer_id=customer_id,
            operation=account_budget_proposal_operation,
        )
    )
    print(
        "Created account budget proposal "
        f'"{account_budget_proposal_response.result.resource_name}".'
    )

Ruby

def add_account_budget_proposal(customer_id, billing_setup_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new


  operation = client.operation.create_resource.account_budget_proposal do |proposal|
    proposal.billing_setup = client.path.billing_setup(customer_id, billing_setup_id)
    proposal.proposal_type = :CREATE
    proposal.proposed_name = 'Account Budget (example)'

    # Specify the account budget starts immediately
    proposal.proposed_start_time_type = :NOW
    # Alternatively you can specify a specific start time. Refer to the
    # AccountBudgetProposal resource documentation for allowed formats.
    #
    # proposal.proposed_start_date_time = '2020-01-02 03:04:05'

    # Specify that the budget runs forever.
    proposal.proposed_end_time_type = :FOREVER
    # Alternatively you can specify a specific end time. Allowed formats are as
    # above.
    #
    # proposal.proposed_end_date_time = '2021-01-02 03:04:05'

    # Optional: set notes for the budget. These are free text and do not affect
    # budget delivery.
    #
    # proposal.proposed_notes = 'Received prepayment of $0.01'

    # Set the spending limit to 0.01, measured in the Google Ads account currency.
    proposal.proposed_spending_limit_micros = 10_000
  end

  account_budget_proposal_service = client.service.account_budget_proposal
  # Add budget proposal.
  response = account_budget_proposal_service.mutate_account_budget_proposal(
    customer_id: customer_id,
    operation: operation,
  )

  puts sprintf("Created budget proposal %s.",
      response.results.first.resource_name)
end

Perl

sub add_account_budget_proposal {
  my ($api_client, $customer_id, $billing_setup_id) = @_;

  # Create an account budget proposal.
  my $account_budget_proposal =
    Google::Ads::GoogleAds::V25::Resources::AccountBudgetProposal->new({
      billingSetup =>
        Google::Ads::GoogleAds::V25::Utils::ResourceNames::billing_setup(
        $customer_id, $billing_setup_id
        ),
      proposalType => CREATE,
      proposedName => "Account Budget (example)",
      # Specify that the account budget starts immediately.
      proposedStartTimeType => NOW,
      # Alternatively you can specify a specific start time. Refer to the
      # AccountBudgetProposal class for allowed formats.
      #
      # proposedStartDateTime => "2020-01-02 03:04:05",

      # Specify that the account budget runs forever.
      proposedEndDateTime => FOREVER,
      # Alternatively you can specify a specific end time. Allowed formats are as below.
      # proposedEndDateTime => "2021-02-03 04:05:06",

      # Optional: set notes for the budget. These are free text and do not effect budget
      # delivery.
      # proposedNotes => "Received prepayment of $0.01",

      # Optional: set PO number for record keeping. This value is at the user's
      # discretion, and has no effect on Google Billing & Payments.
      # proposedPurchaseOrderNumber => "PO number 12345",

      # Set the spending limit to 0.01, measured in the Google Ads account currency.
      proposedSpendingLimitMicros => 10000
    });

  # Create an account budget proposal operation.
  my $account_budget_proposal_operation =
    Google::Ads::GoogleAds::V25::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({
      create => $account_budget_proposal
    });

  # Add the account budget proposal.
  my $account_budget_proposal_response =
    $api_client->AccountBudgetProposalService()->mutate({
      customerId => $customer_id,
      operation  => $account_budget_proposal_operation
    });

  printf "Created account budget proposal '%s'.\n",
    $account_budget_proposal_response->{result}{resourceName};

  return 1;
}

curl

In Anfragen für Kontobudgetvorschläge werden proposed_start_date_time und proposed_end_date_time immer in der Zeitzone des Kundenkontos angegeben. Sie können keine Zeitzone festlegen. Das vorgeschlagene Ausgabenlimit wird immer in der Währung des Kontos angegeben. Geben Sie es in „Mikro“-Einheiten an, z. B. 1,00 $ = 1.000.000 Mikro.

Optional können Sie eine Auftragsnummer angeben, die auf der Rechnung neben diesen Kosten angezeigt wird. Dies hat keine Auswirkungen auf die Budgetauslieferung.

Ausstehenden Vorschlag für ein Kontobudget entfernen

Sie können einen ausstehenden Budgetvorschlag entfernen, indem Sie eine AccountBudgetProposalOperation.remove Anfrage mit einem Ressourcennamen für einen Kontobudgetvorschlag senden. Budgetvorschläge werden jedoch in der Regel innerhalb weniger Minuten angewendet.

Java
AccountBudgetProposalOperation operation = AccountBudgetProposalOperation.newBuilder()
  .setRemove(ResourceNames.accountBudgetProposal(customerId, accountBudgetProposalId))
  .build();

// Send request to Google Ads API (not shown).
C#
AccountBudgetProposalOperation operation = new AccountBudgetProposalOperation()
{
    Remove = ResourceNames.AccountBudgetProposal(customerId, accountBudgetProposalId)
};

// Send request to Google Ads API (not shown).
PHP
$accountBudgetProposalOperation = new AccountBudgetProposalOperation();
$accountBudgetProposalOperation->setRemove(ResourceNames::forAccountBudgetProposal($customerId, $accountBudgetProposalId));

// Send request to Google Ads API (not shown).
Python
account_budget_proposal_service = client.get_service('AccountBudgetProposalService')
account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
account_budget_proposal_operation.remove = (
    account_budget_proposal_service.account_budget_proposal_path(
        customer_id, account_budget_proposal_id
    )
)

# Send request to Google Ads API (not shown).
Ruby
operation = client.operation.remove_resource.account_budget_proposal(client.path.account_budget_proposal(customer_id, account_budget_proposal_id))

# Send request to Google Ads API (not shown).
Perl
my $account_budget_proposal_operation =
  Google::Ads::GoogleAds::V26::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({
      remove => Google::Ads::GoogleAds::V26::Utils::ResourceNames::account_budget_proposal(
          $customer_id, $account_budget_proposal_id
        )
    });

# Send request to Google Ads API (not shown).

Wenn Sie einen Fehler im ursprünglichen Vorschlag gemacht haben, können Sie ihn als UPDATE-Vorgang noch einmal einreichen. Weitere Informationen finden Sie unter Vorhandenes Kontobudget aktualisieren.

Vorhandene Kontobudgets abrufen

Mit der folgenden Google Ads Query Language-Abfrage (GAQL) werden alle vorhandenen Kontobudgets in einem Konto abgerufen:

SELECT
  account_budget.resource_name,
  account_budget.id,
  account_budget.name,
  account_budget.status,
  account_budget.billing_setup,
  account_budget.approved_spending_limit_micros,
  account_budget.approved_spending_limit_type,
  account_budget.proposed_spending_limit_micros,
  account_budget.proposed_spending_limit_type,
  account_budget.adjusted_spending_limit_micros,
  account_budget.adjusted_spending_limit_type,
  account_budget.approved_start_date_time,
  account_budget.proposed_start_date_time,
  account_budget.approved_end_date_time,
  account_budget.approved_end_time_type,
  account_budget.proposed_end_date_time,
  account_budget.proposed_end_time_type
FROM
  account_budget

Für Felder, die die Startzeit, die Endzeit und das Ausgabenlimit des Kontobudgets enthalten, gibt es mehrere Varianten mit Präfixen wie proposed und approved. So können Sie die ursprünglich vorgeschlagenen Werte mit den genehmigten Werten vergleichen. Für das Ausgabenlimit gibt es zusätzliche Felder mit dem Präfix adjusted, die das aktuelle Ausgabenlimit angeben, nachdem alle Anpassungen auf den genehmigten Betrag angewendet wurden.

Das genehmigte Ausgabenlimit eines Kontobudgets kann im Laufe der Zeit angepasst werden, um verschiedene Gutschriften zu berücksichtigen, z. B. für Budgetüberschreitungen, ungültige Klickaktivitäten und Werbegutscheine. Weitere Informationen zu Kontobudgets und Kontoguthaben und Anpassungen finden Sie in der Google Ads-Hilfe.

Alle neuen Kontobudgets, die noch genehmigt werden müssen, sowie alle vorhandenen Konto budgets, für die Aktualisierungen ausstehen, werden auch in der pending_proposal verschachtelten Nachricht angezeigt. Die Unterfelder können in einer GAQL-Abfrage ausgewählt werden, z. B. account_budget_proposal, abgefragt als account_budget.pending_proposal.account_budget_proposal, für den Ressourcen namen des zugehörigen AccountBudgetProposal Objekts.

Vorhandene Kontobudgets verwalten

Nachdem Sie ein Kontobudget für einen Kunden erstellt haben, können Sie mit der AccountBudgetProposalService die Budget parameter verwalten. Die häufigsten Verwaltungsvorgänge sind das Aktualisieren der Felder proposed_spending_limit_micros und proposed_end_date_time. Eine vollständige Liste der änderbaren Felder finden Sie in der AccountBudgetProposal Referenzdokumentation.

Sie haben die Möglichkeit, ein vorhandenes Kontobudget zu aktualisieren oder ein völlig neues Budget zu erstellen. Beide Optionen werden hier gezeigt.

Vorhandenes Kontobudget aktualisieren

Sie können die Felder des vorhandenen Kontobudgets aktualisieren, indem Sie AccountBudgetProposal-Objekte senden, bei denen AccountBudgetProposalType auf UPDATE gesetzt ist. Sie müssen außerdem die Felder angeben, die im Argument update_mask des Vorgangs aktualisiert werden.

Das folgende Snippet zeigt, wie Sie das vorgeschlagene Ausgabenlimit für ein vorhandenes Kontobudget aktualisieren.

Java
AccountBudgetProposal proposal = AccountBudgetProposal.newBuilder()
  .setProposalType(AccountBudgetProposalType.UPDATE)
  .setAccountBudget(accountBudget.getResourceName())
  .setProposedSpendingLimitMicros(
    accountBudget.getProposedSpendingLimitMicros() + increaseAmount)
  .build();

AccountBudgetProposalOperation operation = AccountBudgetProposalOperation.newBuilder()
  .setCreate(proposal)
  .setUpdateMask(
      FieldMask.newBuilder().addAllPaths(Arrays.asList("proposed_spending_limit_micros")).build())
  .build();

// Send request to Google Ads API (not shown).
C#
AccountBudgetProposal proposal = new AccountBudgetProposal()
{
  ProposalType = AccountBudgetProposalType.Update,
  AccountBudget = accountBudget.ResourceName,
  ProposedSpendingLimitMicros = accountBudget.ProposedSpendingLimitMicros + increaseAmount
};

AccountBudgetProposalOperation operation = new AccountBudgetProposalOperation()
{
  Create = proposal,
  UpdateMask = new FieldMask()
  {
    Paths = { "proposed_spending_limit_micros" }
  }
};

// Send request to Google Ads API (not shown).
PHP
$accountBudgetProposal = new AccountBudgetProposal([
  'proposal_type' => AccountBudgetProposalType::UPDATE,
  'account_budget' => $accountBudget->getResourceName(),
  'proposed_spending_limit_micros' =>
    $accountBudget->getProposedSpendingLimitMicros() + $increaseAmount
]);

$accountBudgetProposalOperation = new AccountBudgetProposalOperation();
$accountBudgetProposalOperation->setCreate($accountBudgetProposal);
$accountBudgetProposalOperation->setUpdateMask(
  FieldMasks::allSetFieldsOf($accountBudgetProposal)
);

// Send request to Google Ads API (not shown).
Python
account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')

proposal = account_budget_proposal_operation.create
proposal.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').AccountBudgetProposalType.UPDATE
proposal.account_budget = account_budget.resource_name
proposal.proposed_spending_limit_micros = account_budget.proposed_spending_limit_micros + increase_amount

field_mask = protobuf_helpers.field_mask(None, proposal._pb)
account_budget_proposal_operation.update_mask.CopyFrom(field_mask)

# Send request to Google Ads API (not shown).
Ruby
proposal = client.resource.account_budget_proposal
proposal.proposal_type = :UPDATE

mask = client.field_mask.with proposal do
  proposal.account_budget = account_budget.resource_name
  proposal.proposed_spending_limit_micros = account_budget.proposed_spending_limit_micros + increase_amount
end

operation = client.operation.account_budget_proposal do |op|
  op.create = proposal
  op.update_mask = mask
end

# Send request to Google Ads API (not shown).
Perl
my $account_budget_proposal =
  Google::Ads::GoogleAds::V26::Resources::AccountBudgetProposal->new({
    proposalType => UPDATE,
    accountBudget => $account_budget->{resourceName},
    proposedSpendingLimitMicros => $account_budget->{proposedSpendingLimitMicros} + $increaseAmount});

my $account_budget_proposal_operation =
  Google::Ads::GoogleAds::V26::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({
      create => $account_budget_proposal,
      updateMask => all_set_fields_of($account_budget_proposal)});

# Send request to Google Ads API (not shown).

Verkettung von Kontobudgets

Alternativ zum Aktualisieren des vorhandenen Budgets können Sie in Google Ads mehrere Kontobudgets verketten, die nacheinander ausgeführt werden. Im folgenden Beispiel hat ein Kunde jeden Monat unterschiedliche Ausgabenlimits.

Diagramm mit einer Kette von Kontobudgets mit unterschiedlichen Ausgabengrenzen pro Monat.
Beispiel für die Verkettung von Kontobudgets.

Dazu müssen Sie drei AccountBudgetProposal-Objekte erstellen und jede AccountBudgetProposalOperation in einer separaten MutateAccountBudgetProposal-Anfrage an die AccountBudgetProposalService senden, da MutateAccountBudgetProposalRequest nur einen operation-Vorgang pro Aufruf akzeptiert.

Das folgende Snippet zeigt die Erstellung einer solchen Kette mit einer vorhandenen Abrechnungseinrichtung.

Java
AccountBudgetProposal proposalMay = AccountBudgetProposal.newBuilder()
  .setBillingSetup(ResourceNames.billingSetup(customerId, billingSetupId))
  .setProposalType(AccountBudgetProposalType.CREATE)
  .setProposedName("May budget")
  .setProposedStartDateTime("2027-05-01 00:00:00")
  .setProposedEndDateTime("2027-06-01 00:00:00")
  .setProposedSpendingLimitMicros(1_000_000_000L)
  .build();

AccountBudgetProposalOperation operationMay = AccountBudgetProposalOperation.newBuilder()
  .setCreate(proposalMay)
  .build();

AccountBudgetProposal proposalJune = AccountBudgetProposal.newBuilder()
  .setBillingSetup(ResourceNames.billingSetup(customerId, billingSetupId))
  .setProposalType(AccountBudgetProposalType.CREATE)
  .setProposedName("June budget")
  .setProposedStartDateTime("2027-06-01 00:00:00")
  .setProposedEndDateTime("2027-07-01 00:00:00")
  .setProposedSpendingLimitMicros(5_000_000_000L)
  .build();

AccountBudgetProposalOperation operationJune = AccountBudgetProposalOperation.newBuilder()
  .setCreate(proposalJune)
  .build();

AccountBudgetProposal proposalJuly = AccountBudgetProposal.newBuilder()
  .setBillingSetup(ResourceNames.billingSetup(customerId, billingSetupId))
  .setProposalType(AccountBudgetProposalType.CREATE)
  .setProposedName("July budget")
  .setProposedStartDateTime("2027-07-01 00:00:00")
  .setProposedEndDateTime("2027-08-01 00:00:00")
  .setProposedSpendingLimitMicros(1_000_000_000L)
  .build();

AccountBudgetProposalOperation operationJuly = AccountBudgetProposalOperation.newBuilder()
  .setCreate(proposalJuly)
  .build();

// Send requests to Google Ads API, one MutateAccountBudgetProposal call per operation (not shown).
C#
AccountBudgetProposal proposalMay = new AccountBudgetProposal()
{
  BillingSetup = ResourceNames.BillingSetup(customerId, billingSetupId),
  ProposalType = AccountBudgetProposalType.Create,
  ProposedName = "May budget",
  ProposedStartDateTime = "2027-05-01 00:00:00",
  ProposedEndDateTime = "2027-06-01 00:00:00",
  ProposedSpendingLimitMicros = 1_000_000_000
};

AccountBudgetProposalOperation operationMay = new AccountBudgetProposalOperation()
{
  Create = proposalMay
};

AccountBudgetProposal proposalJune = new AccountBudgetProposal()
{
  BillingSetup = ResourceNames.BillingSetup(customerId, billingSetupId),
  ProposalType = AccountBudgetProposalType.Create,
  ProposedName = "June budget",
  ProposedStartDateTime = "2027-06-01 00:00:00",
  ProposedEndDateTime = "2027-07-01 00:00:00",
  ProposedSpendingLimitMicros = 5_000_000_000
};

AccountBudgetProposalOperation operationJune = new AccountBudgetProposalOperation()
{
  Create = proposalJune
};

AccountBudgetProposal proposalJuly = new AccountBudgetProposal()
{
  BillingSetup = ResourceNames.BillingSetup(customerId, billingSetupId),
  ProposalType = AccountBudgetProposalType.Create,
  ProposedName = "July budget",
  ProposedStartDateTime = "2027-07-01 00:00:00",
  ProposedEndDateTime = "2027-08-01 00:00:00",
  ProposedSpendingLimitMicros = 1_000_000_000
};

AccountBudgetProposalOperation operationJuly = new AccountBudgetProposalOperation()
{
  Create = proposalJuly
};

// Send requests to Google Ads API, one MutateAccountBudgetProposal call per operation (not shown).
PHP
$proposalMay = new AccountBudgetProposal([
  'billing_setup' => ResourceNames::forBillingSetup($customerId, $billingSetupId),
  'proposal_type' => AccountBudgetProposalType::CREATE,
  'proposed_name' => 'May budget',
  'proposed_start_date_time' => '2027-05-01 00:00:00',
  'proposed_end_date_time' => '2027-06-01 00:00:00',
  'proposed_spending_limit_micros' => 1000000000
]);
$operationMay = new AccountBudgetProposalOperation();
$operationMay->setCreate($proposalMay);

$proposalJune = new AccountBudgetProposal([
  'billing_setup' => ResourceNames::forBillingSetup($customerId, $billingSetupId),
  'proposal_type' => AccountBudgetProposalType::CREATE,
  'proposed_name' => 'June budget',
  'proposed_start_date_time' => '2027-06-01 00:00:00',
  'proposed_end_date_time' => '2027-07-01 00:00:00',
  'proposed_spending_limit_micros' => 5000000000
]);
$operationJune = new AccountBudgetProposalOperation();
$operationJune->setCreate($proposalJune);

$proposalJuly = new AccountBudgetProposal([
  'billing_setup' => ResourceNames::forBillingSetup($customerId, $billingSetupId),
  'proposal_type' => AccountBudgetProposalType::CREATE,
  'proposed_name' => 'July budget',
  'proposed_start_date_time' => '2027-07-01 00:00:00',
  'proposed_end_date_time' => '2027-08-01 00:00:00',
  'proposed_spending_limit_micros' => 1000000000
]);
$operationJuly = new AccountBudgetProposalOperation();
$operationJuly->setCreate($proposalJuly);

// Send requests to Google Ads API, one MutateAccountBudgetProposal call per operation (not shown).
Python
billing_setup_service = client.get_service('BillingSetupService')

may_account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposal_may = may_account_budget_proposal_operation.create
proposal_may.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').AccountBudgetProposalType.CREATE
proposal_may.billing_setup = billing_setup_service.billing_setup_path(customer_id, billing_setup_id)
proposal_may.proposed_name = 'May budget'
proposal_may.proposed_start_date_time = '2027-05-01 00:00:00'
proposal_may.proposed_end_date_time = '2027-06-01 00:00:00'
proposal_may.proposed_spending_limit_micros = 1000000000

june_account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposal_june = june_account_budget_proposal_operation.create
proposal_june.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').AccountBudgetProposalType.CREATE
proposal_june.billing_setup = billing_setup_service.billing_setup_path(customer_id, billing_setup_id)
proposal_june.proposed_name = 'June budget'
proposal_june.proposed_start_date_time = '2027-06-01 00:00:00'
proposal_june.proposed_end_date_time = '2027-07-01 00:00:00'
proposal_june.proposed_spending_limit_micros = 5000000000

july_account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposal_july = july_account_budget_proposal_operation.create
proposal_july.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').AccountBudgetProposalType.CREATE
proposal_july.billing_setup = billing_setup_service.billing_setup_path(customer_id, billing_setup_id)
proposal_july.proposed_name = 'July budget'
proposal_july.proposed_start_date_time = '2027-07-01 00:00:00'
proposal_july.proposed_end_date_time = '2027-08-01 00:00:00'
proposal_july.proposed_spending_limit_micros = 1000000000

# Send requests to Google Ads API, one MutateAccountBudgetProposal call per operation (not shown).
Ruby
operation_may = client.operation.create_resource.account_budget_proposal do |proposal|
  proposal.billing_setup = client.path.billing_setup(customer_id, billing_setup_id)
  proposal.proposal_type = :CREATE
  proposal.proposed_name = 'May budget'
  proposal.proposed_start_date_time = '2027-05-01 00:00:00'
  proposal.proposed_end_date_time = '2027-06-01 00:00:00'
  proposal.proposed_spending_limit_micros = 1_000_000_000
end

operation_june = client.operation.create_resource.account_budget_proposal do |proposal|
  proposal.billing_setup = client.path.billing_setup(customer_id, billing_setup_id)
  proposal.proposal_type = :CREATE
  proposal.proposed_name = 'June budget'
  proposal.proposed_start_date_time = '2027-06-01 00:00:00'
  proposal.proposed_end_date_time = '2027-07-01 00:00:00'
  proposal.proposed_spending_limit_micros = 5_000_000_000
end

operation_july = client.operation.create_resource.account_budget_proposal do |proposal|
  proposal.billing_setup = client.path.billing_setup(customer_id, billing_setup_id)
  proposal.proposal_type = :CREATE
  proposal.proposed_name = 'July budget'
  proposal.proposed_start_date_time = '2027-07-01 00:00:00'
  proposal.proposed_end_date_time = '2027-08-01 00:00:00'
  proposal.proposed_spending_limit_micros = 1_000_000_000
end

# Send requests to Google Ads API, one MutateAccountBudgetProposal call per operation (not shown).
Perl
my $may_proposal =
  Google::Ads::GoogleAds::V26::Resources::AccountBudgetProposal->new({
    billingSetup =>
      Google::Ads::GoogleAds::V26::Utils::ResourceNames::billing_setup(
      $customer_id, $billing_setup_id
      ),
    proposalType => CREATE,
    proposedName => "May budget",
    proposedStartDateTime => "2027-05-01 00:00:00",
    proposedEndDateTime => "2027-06-01 00:00:00",
    proposedSpendingLimitMicros => 1000000000
  });
my $may_operation =
  Google::Ads::GoogleAds::V26::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({create => $may_proposal});

my $june_proposal =
  Google::Ads::GoogleAds::V26::Resources::AccountBudgetProposal->new({
    billingSetup =>
      Google::Ads::GoogleAds::V26::Utils::ResourceNames::billing_setup(
      $customer_id, $billing_setup_id
      ),
    proposalType => CREATE,
    proposedName => "June budget",
    proposedStartDateTime => "2027-06-01 00:00:00",
    proposedEndDateTime => "2027-07-01 00:00:00",
    proposedSpendingLimitMicros => 5000000000
  });
my $june_operation =
  Google::Ads::GoogleAds::V26::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({create => $june_proposal});

my $july_proposal =
  Google::Ads::GoogleAds::V26::Resources::AccountBudgetProposal->new({
    billingSetup =>
      Google::Ads::GoogleAds::V26::Utils::ResourceNames::billing_setup(
      $customer_id, $billing_setup_id
      ),
    proposalType => CREATE,
    proposedName => "July budget",
    proposedStartDateTime => "2027-07-01 00:00:00",
    proposedEndDateTime => "2027-08-01 00:00:00",
    proposedSpendingLimitMicros => 1000000000
  });
my $july_operation =
  Google::Ads::GoogleAds::V26::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({create => $july_proposal});

# Send requests to Google Ads API, one MutateAccountBudgetProposal call per operation (not shown).

Beachten Sie die Verwendung von AccountBudgetProposalType.CREATE für jeden Vorschlag. Dadurch werden drei verschiedene Budgets erstellt, anstatt dasselbe Budget dreimal aktualisiert wird.

Kontobudgets beenden

Kontobudgets können beendet werden, während sie aktiv sind, und vor dem Start oder während der Genehmigung vollständig entfernt werden.

Aktives Kontobudget beenden

Das aktive Kontobudget kann nicht entfernt werden. Sie können jedoch die Endzeit auf die aktuelle Zeit festlegen. Am einfachsten geht das, indem Sie einen Vorschlag mit AccountBudgetProposalType.END senden.

Das folgende Snippet zeigt, wie Sie ein vorhandenes Kontobudget beenden.

Java
AccountBudgetProposal proposal = AccountBudgetProposal.newBuilder()
  .setProposalType(AccountBudgetProposalType.END)
  .setAccountBudget(accountBudget.getResourceName())
  .build();

AccountBudgetProposalOperation operation = AccountBudgetProposalOperation.newBuilder()
  .setCreate(proposal)
  .build();

// Send request to Google Ads API (not shown).
C#
AccountBudgetProposal proposal = new AccountBudgetProposal()
{
  ProposalType = AccountBudgetProposalType.End,
  AccountBudget = accountBudget.ResourceName
};

AccountBudgetProposalOperation operation = new AccountBudgetProposalOperation()
{
  Create = proposal
};

// Send request to Google Ads API (not shown).
PHP
$accountBudgetProposal = new AccountBudgetProposal([
  'proposal_type' => AccountBudgetProposalType::END,
  'account_budget' => $accountBudget->getResourceName()
]);

$accountBudgetProposalOperation = new AccountBudgetProposalOperation();
$accountBudgetProposalOperation->setCreate($accountBudgetProposal);

// Send request to Google Ads API (not shown).
Python
account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposal = account_budget_proposal_operation.create
proposal.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').AccountBudgetProposalType.END
proposal.account_budget = account_budget.resource_name

# Send request to Google Ads API (not shown).
Ruby
operation = client.operation.create_resource.account_budget_proposal do |proposal|
  proposal.proposal_type = :END
  proposal.account_budget = account_budget.resource_name
end

# Send request to Google Ads API (not shown).
Perl
my $account_budget_proposal =
  Google::Ads::GoogleAds::V26::Resources::AccountBudgetProposal->new({
    proposalType => END,
    accountBudget => $account_budget->{resourceName}
  });

my $account_budget_proposal_operation =
  Google::Ads::GoogleAds::V26::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({create => $account_budget_proposal});

# Send request to Google Ads API (not shown).

Das entspricht der Aktualisierung eines Kontobudgets, indem Sie die End zeit auf TimeType.NOW setzen.

Genehmigtes Kontobudget vor dem Start entfernen

Wenn Sie ein Kontobudget vorgeschlagen haben, das in der Zukunft beginnen soll, können Sie es vor dem Start vollständig entfernen, indem Sie einen AccountBudgetProposalType.REMOVE Vorschlag senden.

Das folgende Snippet zeigt das Entfernen eines vorhandenen zukünftigen Kontobudgets.

Java
AccountBudgetProposal proposal = AccountBudgetProposal.newBuilder()
  .setProposalType(AccountBudgetProposalType.REMOVE)
  .setAccountBudget(accountBudget.getResourceName())
  .build();

AccountBudgetProposalOperation operation = AccountBudgetProposalOperation.newBuilder()
  .setCreate(proposal)
  .build();

// Send request to Google Ads API (not shown).
C#
AccountBudgetProposal proposal = new AccountBudgetProposal()
{
  ProposalType = AccountBudgetProposalType.Remove,
  AccountBudget = accountBudget.ResourceName
};

AccountBudgetProposalOperation operation = new AccountBudgetProposalOperation()
{
  Create = proposal
};

// Send request to Google Ads API (not shown).
PHP
$accountBudgetProposal = new AccountBudgetProposal([
  'proposal_type' => AccountBudgetProposalType::REMOVE,
  'account_budget' => $accountBudget->getResourceName()
]);

$accountBudgetProposalOperation = new AccountBudgetProposalOperation();
$accountBudgetProposalOperation->setCreate($accountBudgetProposal);

// Send request to Google Ads API (not shown).
Python
account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposal = account_budget_proposal_operation.create
proposal.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').AccountBudgetProposalType.REMOVE
proposal.account_budget = account_budget.resource_name

# Send request to Google Ads API (not shown).
Ruby
operation = client.operation.create_resource.account_budget_proposal do |proposal|
  proposal.proposal_type = :REMOVE
  proposal.account_budget = account_budget.resource_name
end

# Send request to Google Ads API (not shown).
Perl
my $account_budget_proposal =
  Google::Ads::GoogleAds::V26::Resources::AccountBudgetProposal->new({
    proposalType => REMOVE,
    accountBudget => $account_budget->{resourceName}
  });

my $account_budget_proposal_operation =
  Google::Ads::GoogleAds::V26::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({create => $account_budget_proposal});

# Send request to Google Ads API (not shown).
Zurück
Einrichtung des Abrechnungsplans
Weiter
Rechnung