<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="content_v2_1.html">Content API for Shopping</a> . <a href="content_v2_1.buyongoogleprograms.html">buyongoogleprograms</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#activate">activate(merchantId, regionCode, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Reactivates the BoG program in your Merchant Center account. Moves the program to the active state when allowed, e.g. when paused. Important: This method is only whitelisted for selected merchants.</p>
<p class="toc_element">
  <code><a href="#close">close()</a></code></p>
<p class="firstline">Close httplib2 connections.</p>
<p class="toc_element">
  <code><a href="#get">get(merchantId, regionCode, x__xgafv=None)</a></code></p>
<p class="firstline">Retrieves a status of the BoG program for your Merchant Center account.</p>
<p class="toc_element">
  <code><a href="#onboard">onboard(merchantId, regionCode, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Onboards the BoG program in your Merchant Center account. By using this method, you agree to the [Terms of Service](https://merchants.google.com/mc/termsofservice/transactions/US/latest). Calling this method is only possible if the authenticated account is the same as the merchant id in the request. Calling this method multiple times will only accept Terms of Service if the latest version is not currently signed.</p>
<p class="toc_element">
  <code><a href="#patch">patch(merchantId, regionCode, body=None, updateMask=None, x__xgafv=None)</a></code></p>
<p class="firstline">Updates the status of the BoG program for your Merchant Center account.</p>
<p class="toc_element">
  <code><a href="#pause">pause(merchantId, regionCode, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Pauses the BoG program in your Merchant Center account. Important: This method is only whitelisted for selected merchants.</p>
<p class="toc_element">
  <code><a href="#requestreview">requestreview(merchantId, regionCode, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Requests review and then activates the BoG program in your Merchant Center account for the first time. Moves the program to the REVIEW_PENDING state. Important: This method is only whitelisted for selected merchants.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="activate">activate(merchantId, regionCode, body=None, x__xgafv=None)</code>
  <pre>Reactivates the BoG program in your Merchant Center account. Moves the program to the active state when allowed, e.g. when paused. Important: This method is only whitelisted for selected merchants.

Args:
  merchantId: string, Required. The ID of the account. (required)
  regionCode: string, Required. The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available. (required)
  body: object, The request body.
    The object takes the form of:

{ # Request message for the ActivateProgram method.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
</pre>
</div>

<div class="method">
    <code class="details" id="close">close()</code>
  <pre>Close httplib2 connections.</pre>
</div>

<div class="method">
    <code class="details" id="get">get(merchantId, regionCode, x__xgafv=None)</code>
  <pre>Retrieves a status of the BoG program for your Merchant Center account.

Args:
  merchantId: string, Required. The ID of the account. (required)
  regionCode: string, Required. The Program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response message for the GetProgramStatus method.
  &quot;businessModel&quot;: [ # The business models in which merchant participates.
    &quot;A String&quot;,
  ],
  &quot;customerServicePendingEmail&quot;: &quot;A String&quot;, # The customer service pending email. After verification this field becomes empty.
  &quot;customerServicePendingPhoneNumber&quot;: &quot;A String&quot;, # The pending phone number specified for BuyOnGoogle program. It might be different than account level phone number. In order to update this field the customer_service_pending_phone_region_code must also be set. After verification this field becomes empty.
  &quot;customerServicePendingPhoneRegionCode&quot;: &quot;A String&quot;, # Two letter country code for the pending phone number, for example `CA` for Canadian numbers. See the [ISO 3166-1 alpha-2](https://wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) officially assigned codes. In order to update this field the customer_service_pending_phone_number must also be set. After verification this field becomes empty.
  &quot;customerServiceVerifiedEmail&quot;: &quot;A String&quot;, # Output only. The customer service verified email.
  &quot;customerServiceVerifiedPhoneNumber&quot;: &quot;A String&quot;, # Output only. The verified phone number specified for BuyOnGoogle program. It might be different than account level phone number.
  &quot;customerServiceVerifiedPhoneRegionCode&quot;: &quot;A String&quot;, # Output only. Two letter country code for the verified phone number, for example `CA` for Canadian numbers. See the [ISO 3166-1 alpha-2](https://wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) officially assigned codes.
  &quot;onlineSalesChannel&quot;: &quot;A String&quot;, # The channels through which the merchant is selling.
  &quot;participationStage&quot;: &quot;A String&quot;, # Output only. The current participation stage for the program.
}</pre>
</div>

<div class="method">
    <code class="details" id="onboard">onboard(merchantId, regionCode, body=None, x__xgafv=None)</code>
  <pre>Onboards the BoG program in your Merchant Center account. By using this method, you agree to the [Terms of Service](https://merchants.google.com/mc/termsofservice/transactions/US/latest). Calling this method is only possible if the authenticated account is the same as the merchant id in the request. Calling this method multiple times will only accept Terms of Service if the latest version is not currently signed.

Args:
  merchantId: string, Required. The ID of the account. (required)
  regionCode: string, Required. The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available. (required)
  body: object, The request body.
    The object takes the form of:

{ # Request message for the OnboardProgram method.
  &quot;customerServiceEmail&quot;: &quot;A String&quot;, # The customer service email.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
</pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(merchantId, regionCode, body=None, updateMask=None, x__xgafv=None)</code>
  <pre>Updates the status of the BoG program for your Merchant Center account.

Args:
  merchantId: string, Required. The ID of the account. (required)
  regionCode: string, Required. The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available. (required)
  body: object, The request body.
    The object takes the form of:

{ # Response message for the GetProgramStatus method.
  &quot;businessModel&quot;: [ # The business models in which merchant participates.
    &quot;A String&quot;,
  ],
  &quot;customerServicePendingEmail&quot;: &quot;A String&quot;, # The customer service pending email. After verification this field becomes empty.
  &quot;customerServicePendingPhoneNumber&quot;: &quot;A String&quot;, # The pending phone number specified for BuyOnGoogle program. It might be different than account level phone number. In order to update this field the customer_service_pending_phone_region_code must also be set. After verification this field becomes empty.
  &quot;customerServicePendingPhoneRegionCode&quot;: &quot;A String&quot;, # Two letter country code for the pending phone number, for example `CA` for Canadian numbers. See the [ISO 3166-1 alpha-2](https://wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) officially assigned codes. In order to update this field the customer_service_pending_phone_number must also be set. After verification this field becomes empty.
  &quot;customerServiceVerifiedEmail&quot;: &quot;A String&quot;, # Output only. The customer service verified email.
  &quot;customerServiceVerifiedPhoneNumber&quot;: &quot;A String&quot;, # Output only. The verified phone number specified for BuyOnGoogle program. It might be different than account level phone number.
  &quot;customerServiceVerifiedPhoneRegionCode&quot;: &quot;A String&quot;, # Output only. Two letter country code for the verified phone number, for example `CA` for Canadian numbers. See the [ISO 3166-1 alpha-2](https://wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) officially assigned codes.
  &quot;onlineSalesChannel&quot;: &quot;A String&quot;, # The channels through which the merchant is selling.
  &quot;participationStage&quot;: &quot;A String&quot;, # Output only. The current participation stage for the program.
}

  updateMask: string, The list of fields to update. If the update mask is not provided, then all the fields set in buyOnGoogleProgramStatus will be updated. Clearing fields is only possible if update mask is provided.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response message for the GetProgramStatus method.
  &quot;businessModel&quot;: [ # The business models in which merchant participates.
    &quot;A String&quot;,
  ],
  &quot;customerServicePendingEmail&quot;: &quot;A String&quot;, # The customer service pending email. After verification this field becomes empty.
  &quot;customerServicePendingPhoneNumber&quot;: &quot;A String&quot;, # The pending phone number specified for BuyOnGoogle program. It might be different than account level phone number. In order to update this field the customer_service_pending_phone_region_code must also be set. After verification this field becomes empty.
  &quot;customerServicePendingPhoneRegionCode&quot;: &quot;A String&quot;, # Two letter country code for the pending phone number, for example `CA` for Canadian numbers. See the [ISO 3166-1 alpha-2](https://wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) officially assigned codes. In order to update this field the customer_service_pending_phone_number must also be set. After verification this field becomes empty.
  &quot;customerServiceVerifiedEmail&quot;: &quot;A String&quot;, # Output only. The customer service verified email.
  &quot;customerServiceVerifiedPhoneNumber&quot;: &quot;A String&quot;, # Output only. The verified phone number specified for BuyOnGoogle program. It might be different than account level phone number.
  &quot;customerServiceVerifiedPhoneRegionCode&quot;: &quot;A String&quot;, # Output only. Two letter country code for the verified phone number, for example `CA` for Canadian numbers. See the [ISO 3166-1 alpha-2](https://wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) officially assigned codes.
  &quot;onlineSalesChannel&quot;: &quot;A String&quot;, # The channels through which the merchant is selling.
  &quot;participationStage&quot;: &quot;A String&quot;, # Output only. The current participation stage for the program.
}</pre>
</div>

<div class="method">
    <code class="details" id="pause">pause(merchantId, regionCode, body=None, x__xgafv=None)</code>
  <pre>Pauses the BoG program in your Merchant Center account. Important: This method is only whitelisted for selected merchants.

Args:
  merchantId: string, Required. The ID of the account. (required)
  regionCode: string, Required. The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available. (required)
  body: object, The request body.
    The object takes the form of:

{ # Request message for the PauseProgram method.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
</pre>
</div>

<div class="method">
    <code class="details" id="requestreview">requestreview(merchantId, regionCode, body=None, x__xgafv=None)</code>
  <pre>Requests review and then activates the BoG program in your Merchant Center account for the first time. Moves the program to the REVIEW_PENDING state. Important: This method is only whitelisted for selected merchants.

Args:
  merchantId: string, Required. The ID of the account. (required)
  regionCode: string, Required. The program region code [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2). Currently only US is available. (required)
  body: object, The request body.
    The object takes the form of:

{ # Request message for the RequestReviewProgram method.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
</pre>
</div>

</body></html>