Presupuesto de la cuenta

Los presupuestos de la cuenta controlan lo que una cuenta puede invertir durante un período específico mediante la definición de propiedades del presupuesto, como el límite de inversión, la hora de inicio y la hora de finalización. Deben apuntar a una de las configuraciones de facturación de la cuenta para indicar a qué cuenta de pagos específica se le facturará. Puedes crear, actualizar y quitar el objeto AccountBudget enviando objetos AccountBudgetProposal.

Los objetos AccountBudget representan el resultado final de la aplicación de propuestas. Después de que se apruebe una propuesta, sus cambios (sujetos a ajustes) generarán la creación de un presupuesto de cuenta nuevo o la actualización de uno existente. Esto depende de la proposal_type especificada en la solicitud.

AccountBudgetProposalType Descripción
CREATE Crea un presupuesto de cuenta nuevo, que se debe aprobar antes de usarlo.
UPDATE Modifica el presupuesto de una cuenta existente.
END Establece la hora de finalización del presupuesto de una cuenta en la hora actual.
REMOVE Quita el presupuesto de una cuenta antes de su hora de inicio.

En las siguientes secciones, se describe el comportamiento de cada tipo de propuesta.

Cómo crear una propuesta de presupuesto de la cuenta

Crear un nuevo presupuesto de la cuenta te permite controlar el comportamiento de gasto de un cliente. Usa AccountBudgetProposalService para crear un AccountBudgetProposal nuevo. Debes establecer proposal_type en CREATE para especificar que se debe crear un presupuesto nuevo. Consulta la sección administración de esta guía para conocer otras operaciones.

Recuerda usar una configuración de facturación con una cuenta de pagos en la que tengas acceso de escritura. Consulta la guía de configuración de facturación para obtener más detalles.

En el siguiente ejemplo, se muestra cómo crear una nueva propuesta de presupuesto.

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());
  }
}
AddAccountBudgetProposal.java

C#

public void Run(GoogleAdsClient client, long customerId, long billingSetupId)
{
    // Get the AccountBudgetProposalServiceClient.
    AccountBudgetProposalServiceClient proposalService =
        client.GetService(Services.V18.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;
    }
}
AddAccountBudgetProposal.cs

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
    );
}
AddAccountBudgetProposal.php

Python

def main(client, customer_id, billing_setup_id):
    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}".'
    )
add_account_budget_proposal.py

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
add_account_budget_proposal.rb

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::V18::Resources::AccountBudgetProposal->new({
      billingSetup =>
        Google::Ads::GoogleAds::V18::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::V18::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;
}
add_account_budget_proposal.pl

En las solicitudes de propuestas de presupuesto de la cuenta, proposed_start_date_time y proposed_end_date_time siempre están en la zona horaria de la cuenta del cliente. No puedes especificar una zona horaria. El límite de inversión propuesto siempre se mide en la moneda de la cuenta. Especifícalo con unidades de "micro", de modo que USD 1.00 = 1,000,000 de micros.

De forma opcional, puedes incluir un número de orden de compra que aparecerá junto a estos cargos en la factura. Esto no tiene ningún efecto en la publicación del presupuesto.

Cómo quitar una propuesta de presupuesto de la cuenta pendiente

Para quitar una propuesta de presupuesto pendiente por completo, envía una solicitud AccountBudgetProposalOperation Remove con el nombre del recurso de propuesta de presupuesto de la cuenta. Sin embargo, ten en cuenta que las propuestas de presupuesto suelen aplicarse en minutos.

Java
AccountBudgetProposalOperation operation = AccountBudgetProposalOperation.newBuilder()
  .setRemove(StringValue.of(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')
proposal = account_budget_proposal_operation.remove
proposal.resource_name = 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::V18::Services::AccountBudgetProposalService::AccountBudgetProposalOperation
    ->new({
      remove => Google::Ads::GoogleAds::V18::Utils::ResourceNames::billing_setup(
          $customer_id, $account_budget_proposal_id
        )
    });

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

Si cometiste un error con la propuesta original, puedes volver a enviarla como una operación UPDATE. Consulta la sección Cómo administrar los presupuestos de las cuentas existentes a continuación para obtener más información.

Cómo recuperar los presupuestos de la cuenta existentes

La siguiente consulta de GAQL recupera todos los presupuestos de cuenta existentes en una cuenta:

SELECT
  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

Ten en cuenta que los campos que encapsulan la hora de inicio, la hora de finalización y el límite de inversión del presupuesto de la cuenta tienen varias variantes con prefijos como proposed y approved que permiten comparar los valores que se propusieron inicialmente con los que se aprobaron. El límite de inversión tiene campos adicionales con el prefijo adjusted para indicar el límite de inversión actual vigente después de que se aplicaron los ajustes al importe aprobado.

El límite de inversión aprobado del presupuesto de una cuenta se puede ajustar con el tiempo para reflejar varios créditos, como la sobreimpresión del presupuesto, la actividad de clics no válida y los cupones promocionales. En el Centro de ayuda de Google Ads, puedes encontrar más información sobre los presupuestos de la cuenta y los créditos y ajustes de la cuenta.

Los presupuestos de cuentas nuevos pendientes de aprobación, junto con los presupuestos de cuentas existentes que tengan actualizaciones pendientes, también contendrán un campo pending_proposal que se puede seleccionar. Contendrá el ID del recurso del objeto AccountBudgetProposal asociado.

Administra los presupuestos de la cuenta existentes

Después de crear un presupuesto de la cuenta para un cliente, puedes usar AccountBudgetProposalService para administrar los parámetros del presupuesto. Las operaciones de administración más comunes son actualizar los campos spending_limit y end_date_time. Para obtener una lista completa de los campos mutables, consulta el documento AccountBudgetProposal.

Tienes la opción de actualizar el presupuesto de una cuenta existente o crear uno completamente nuevo. Ambas opciones se muestran aquí.

Actualiza el presupuesto de una cuenta existente

Para actualizar los campos de presupuesto de la cuenta existentes, envía objetos AccountBudgetProposal con AccountBudgetProposalType configurado en UPDATE. Ten en cuenta que también debes indicar los campos que se actualizarán en el argumento UpdateMask de la operación.

En el siguiente fragmento, se muestra cómo actualizar el límite de gastos propuesto para el presupuesto de una cuenta existente.

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

AccountBudgetProposalOperation operation = AccountBudgetProposalOperation.newBuilder()
  .setCreate(proposal)
  .setUpdateMask(
      FieldMask.newBuilder().addAllPaths(Arrays.asList("proposed_spending_limit")).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" }
  }
};

// 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').UPDATE
proposal.account_budget = account_budget
proposal.proposed_spending_limit_micros = account_budget.proposed_spending_limit_micros + increase_amount

field_mask = protobuf_helpers.field_mask(None, proposal)
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::V18::Resources::AccountBudgetProposal->new({
    proposalType => UPDATE,
    accountBudget => $account_budget->{resourceName},
    proposedSpendingLimitMicros => $account_budget->{proposedSpendingLimitMicros} + $increaseAmount});

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

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

Cadena de presupuestos de la cuenta

Como alternativa a la actualización del presupuesto existente, Google Ads te permite encadenar varios presupuestos de la cuenta para que se ejecuten de forma consecutiva. En el siguiente ejemplo, un cliente tiene diferentes límites de gasto cada mes.

Para ello, crea tres objetos AccountBudgetProposal y envíalos a AccountBudgetProposalService.

En el siguiente fragmento, se muestra la creación de una cadena de este tipo con una configuración de facturación existente.

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

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

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

// Send request to Google Ads API (not shown).
C#
AccountBudgetProposal proposalMay = new AccountBudgetProposal()
{
  BillingSetup = ResourceNames.BillingSetup(customerId, billingSetupId),
  ProposalType = AccountBudgetProposalType.Create,
  ProposedName = "May budget",
  ProposedStartDateTime = "2018-05-01",
  ProposedEndDateTime = "2018-06-01",
  ProposedSpendingLimitMicros = 1_000_000_000
}

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

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

// Send request to Google Ads API (not shown).
PHP
$proposalMay = new AccountBudgetProposal([
  'billing_setup' => ResourceNames::forBillingSetup($customerId, $billingSetupId),
  'proposal_type' => AccountBudgetProposalType::CREATE,
  'proposed_name' => 'May budget',
  'proposed_start_date_time' => '2018-05-01',
  'proposed_end_date_time' => '2018-06-01',
  'proposed_spending_limit_micros' => 1000000000
]);

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

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

// Send request to Google Ads API (not shown).
Python
may_account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposalMay = may_account_budget_proposal_operation.create
proposalMay.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').CREATE
proposalMay.billing_setup = billing_setup_service.billing_setup_path(customer_id, billing_setup_id)
proposalMay.proposed_name = 'May budget'
proposalMay.proposed_start_date_time = '2018-05-01'
proposalMay.proposed_end_date_time = '2018-06-01'
proposalMay.proposed_spending_limit_micros = 1000000000

june_account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposalJune = may_account_budget_proposal_operation.create
proposalJune.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').CREATE
proposalJune.billing_setup = billing_setup_service.billing_setup_path(customer_id, billing_setup_id)
proposalJune.proposed_name = 'June budget'
proposalJune.proposed_start_date_time = '2018-06-01'
proposalJune.proposed_end_date_time = '2018-07-01'
proposalJune.proposed_spending_limit_micros = 5000000000

july_account_budget_proposal_operation = client.get_type('AccountBudgetProposalOperation')
proposalJuly = may_account_budget_proposal_operation.create
proposalJuly.proposal_type = client.get_type('AccountBudgetProposalTypeEnum').CREATE
proposalJuly.billing_setup = billing_setup_service.billing_setup_path(customer_id, billing_setup_id)
proposalJuly.proposed_name = 'July budget'
proposalJuly.proposed_start_date_time = '2018-07-01'
proposalJuly.proposed_end_date_time = '2018-08-01'
proposalJuly.proposed_spending_limit_micros = 1000000000

# Send request to Google Ads API (not shown).
Ruby
proposal_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 = '2018-05-01'
  proposal.proposed_end_date_time = '2018-06-01'
  proposal.proposed_spending_limit_micros = 1_000_000_000
end

proposal_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 = '2018-06-01'
  proposal.proposed_end_date_time = '2018-07-01'
  proposal.proposed_spending_limit_micros = 5_000_000_000
end

proposal_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 = '2018-07-01'
  proposal.proposed_end_date_time = '2018-08-01'
  proposal.proposed_spending_limit_micros = 1_000_000_000
end

# Send request to Google Ads API (not shown).
Perl
my $may_proposal =
  Google::Ads::GoogleAds::V18::Resources::AccountBudgetProposal->new({
    billingSetup =>
      Google::Ads::GoogleAds::V18::Utils::ResourceNames::billing_setup(
      $customer_id, $billing_setup_id
      ),
    proposalType => CREATE,
    proposedName => "May budget",
    proposedStartDateTime => "2018-05-01",
    proposedEndDateTime => "2018-06-01",
    proposedSpendingLimitMicros => 1000000000
  });

my $june_proposal =
  Google::Ads::GoogleAds::V18::Resources::AccountBudgetProposal->new({
    billingSetup =>
      Google::Ads::GoogleAds::V18::Utils::ResourceNames::billing_setup(
      $customer_id, $billing_setup_id
      ),
    proposalType => CREATE,
    proposedName => "June budget",
    proposedStartDateTime => "2018-06-01",
    proposedEndDateTime => "2018-07-01",
    proposedSpendingLimitMicros => 5000000000
  });

my $july_proposal =
  Google::Ads::GoogleAds::V18::Resources::AccountBudgetProposal->new({
    billingSetup =>
      Google::Ads::GoogleAds::V18::Utils::ResourceNames::billing_setup(
      $customer_id, $billing_setup_id
      ),
    proposalType => CREATE,
    proposedName => "July budget",
    proposedStartDateTime => "2018-07-01",
    proposedEndDateTime => "2018-08-01",
    proposedSpendingLimitMicros => 1000000000
  });

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

Ten en cuenta el uso de AccountBudgetProposalType.CREATE en cada propuesta. De esta manera, se crearán tres presupuestos distintos, en lugar de actualizar el mismo presupuesto tres veces.

Cómo finalizar los presupuestos de la cuenta

Los presupuestos de la cuenta se pueden finalizar mientras están activos y quitarse por completo antes de comenzar o mientras están pendientes de aprobación.

Finaliza el presupuesto de la cuenta activa

No se puede quitar el presupuesto activo de la cuenta. Sin embargo, puedes establecer la hora de finalización en la hora actual. La forma más sencilla de lograrlo es enviar una propuesta con AccountBudgetProposalType.END.

En el siguiente fragmento, se muestra cómo finalizar un presupuesto de cuenta existente.

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

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

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

// 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').END
proposal.account_budget = account_budget

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

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

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

Esto equivale a establecer la actualización del presupuesto de una cuenta configurando la fecha de finalización en TimeType.NOW.

Quitar un presupuesto de cuenta aprobado antes de la hora de inicio

Si propusiste un presupuesto de la cuenta para que comience en el futuro, puedes quitarlo por completo antes de la hora de inicio. Para ello, envía un tipo de propuesta AccountBudgetProposalType.REMOVE.

En el siguiente fragmento, se muestra la eliminación de un presupuesto futuro de la cuenta existente.

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

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

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

// 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').REMOVE
proposal.account_budget = account_budget

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

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

# Send request to Google Ads API (not shown).
Anterior
Configuración de facturación
Siguiente
Factura