<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="analyticsadmin_v1alpha.html">Google Analytics Admin API</a> . <a href="analyticsadmin_v1alpha.accounts.html">accounts</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="analyticsadmin_v1alpha.accounts.userLinks.html">userLinks()</a></code>
</p>
<p class="firstline">Returns the userLinks Resource.</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="#delete">delete(name, x__xgafv=None)</a></code></p>
<p class="firstline">Marks target Account as soft-deleted (ie: "trashed") and returns it. This API does not have a method to restore soft-deleted accounts. However, they can be restored using the Trash Can UI. If the accounts are not restored before the expiration time, the account and all child resources (eg: Properties, GoogleAdsLinks, Streams, UserLinks) will be permanently purged. https://support.google.com/analytics/answer/6154772 Returns an error if the target is not found.</p>
<p class="toc_element">
  <code><a href="#get">get(name, x__xgafv=None)</a></code></p>
<p class="firstline">Lookup for a single Account. Throws "Target not found" if no such account found, or if caller does not have permissions to access it.</p>
<p class="toc_element">
  <code><a href="#getDataSharingSettings">getDataSharingSettings(name, x__xgafv=None)</a></code></p>
<p class="firstline">Get data sharing settings on an account. Data sharing settings are singletons.</p>
<p class="toc_element">
  <code><a href="#list">list(pageSize=None, pageToken=None, showDeleted=None, x__xgafv=None)</a></code></p>
<p class="firstline">Returns all accounts accessible by the caller. Note that these accounts might not currently have GA4 properties. Soft-deleted (ie: "trashed") accounts are excluded by default. Returns an empty list if no relevant accounts are found.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#patch">patch(name, body=None, updateMask=None, x__xgafv=None)</a></code></p>
<p class="firstline">Updates an account.</p>
<p class="toc_element">
  <code><a href="#provisionAccountTicket">provisionAccountTicket(body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Requests a ticket for creating an account.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="close">close()</code>
  <pre>Close httplib2 connections.</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(name, x__xgafv=None)</code>
  <pre>Marks target Account as soft-deleted (ie: &quot;trashed&quot;) and returns it. This API does not have a method to restore soft-deleted accounts. However, they can be restored using the Trash Can UI. If the accounts are not restored before the expiration time, the account and all child resources (eg: Properties, GoogleAdsLinks, Streams, UserLinks) will be permanently purged. https://support.google.com/analytics/answer/6154772 Returns an error if the target is not found.

Args:
  name: string, Required. The name of the Account to soft-delete. Format: accounts/{account} Example: &quot;accounts/100&quot; (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.
}</pre>
</div>

<div class="method">
    <code class="details" id="get">get(name, x__xgafv=None)</code>
  <pre>Lookup for a single Account. Throws &quot;Target not found&quot; if no such account found, or if caller does not have permissions to access it.

Args:
  name: string, Required. The name of the account to lookup. Format: accounts/{account} Example: &quot;accounts/100&quot; (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A resource message representing a Google Analytics account.
  &quot;countryCode&quot;: &quot;A String&quot;, # Country of business. Must be a non-deprecated code for a UN M.49 region. https: //unicode.org/cldr/charts/latest/supplem // ental/territory_containment_un_m_49.html
  &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this account was originally created.
  &quot;deleted&quot;: True or False, # Output only. Indicates whether this Account is soft-deleted or not. Deleted accounts are excluded from List results unless specifically requested.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. Human-readable display name for this account.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this account. Format: accounts/{account} Example: &quot;accounts/100&quot;
  &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when account payload fields were last updated.
}</pre>
</div>

<div class="method">
    <code class="details" id="getDataSharingSettings">getDataSharingSettings(name, x__xgafv=None)</code>
  <pre>Get data sharing settings on an account. Data sharing settings are singletons.

Args:
  name: string, Required. The name of the settings to lookup. Format: accounts/{account}/dataSharingSettings Example: &quot;accounts/1000/dataSharingSettings&quot; (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A resource message representing data sharing settings of a Google Analytics account.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name. Format: accounts/{account}/dataSharingSettings Example: &quot;accounts/1000/dataSharingSettings&quot;
  &quot;sharingWithGoogleAnySalesEnabled&quot;: True or False, # Allows any of Google sales to access the data in order to suggest configuration changes to improve results.
  &quot;sharingWithGoogleAssignedSalesEnabled&quot;: True or False, # Allows Google sales teams that are assigned to the customer to access the data in order to suggest configuration changes to improve results. Sales team restrictions still apply when enabled.
  &quot;sharingWithGoogleProductsEnabled&quot;: True or False, # Allows Google to use the data to improve other Google products or services.
  &quot;sharingWithGoogleSupportEnabled&quot;: True or False, # Allows Google support to access the data in order to help troubleshoot issues.
  &quot;sharingWithOthersEnabled&quot;: True or False, # Allows Google to share the data anonymously in aggregate form with others.
}</pre>
</div>

<div class="method">
    <code class="details" id="list">list(pageSize=None, pageToken=None, showDeleted=None, x__xgafv=None)</code>
  <pre>Returns all accounts accessible by the caller. Note that these accounts might not currently have GA4 properties. Soft-deleted (ie: &quot;trashed&quot;) accounts are excluded by default. Returns an empty list if no relevant accounts are found.

Args:
  pageSize: integer, The maximum number of resources to return. The service may return fewer than this value, even if there are additional pages. If unspecified, at most 50 resources will be returned. The maximum value is 200; (higher values will be coerced to the maximum)
  pageToken: string, A page token, received from a previous `ListAccounts` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListAccounts` must match the call that provided the page token.
  showDeleted: boolean, Whether to include soft-deleted (ie: &quot;trashed&quot;) Accounts in the results. Accounts can be inspected to determine whether they are deleted or not.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Request message for ListAccounts RPC.
  &quot;accounts&quot;: [ # Results that were accessible to the caller.
    { # A resource message representing a Google Analytics account.
      &quot;countryCode&quot;: &quot;A String&quot;, # Country of business. Must be a non-deprecated code for a UN M.49 region. https: //unicode.org/cldr/charts/latest/supplem // ental/territory_containment_un_m_49.html
      &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this account was originally created.
      &quot;deleted&quot;: True or False, # Output only. Indicates whether this Account is soft-deleted or not. Deleted accounts are excluded from List results unless specifically requested.
      &quot;displayName&quot;: &quot;A String&quot;, # Required. Human-readable display name for this account.
      &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this account. Format: accounts/{account} Example: &quot;accounts/100&quot;
      &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when account payload fields were last updated.
    },
  ],
  &quot;nextPageToken&quot;: &quot;A String&quot;, # A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
}</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call &#x27;execute()&#x27; on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(name, body=None, updateMask=None, x__xgafv=None)</code>
  <pre>Updates an account.

Args:
  name: string, Output only. Resource name of this account. Format: accounts/{account} Example: &quot;accounts/100&quot; (required)
  body: object, The request body.
    The object takes the form of:

{ # A resource message representing a Google Analytics account.
  &quot;countryCode&quot;: &quot;A String&quot;, # Country of business. Must be a non-deprecated code for a UN M.49 region. https: //unicode.org/cldr/charts/latest/supplem // ental/territory_containment_un_m_49.html
  &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this account was originally created.
  &quot;deleted&quot;: True or False, # Output only. Indicates whether this Account is soft-deleted or not. Deleted accounts are excluded from List results unless specifically requested.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. Human-readable display name for this account.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this account. Format: accounts/{account} Example: &quot;accounts/100&quot;
  &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when account payload fields were last updated.
}

  updateMask: string, The list of fields to be updated. Omitted fields will not be updated.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A resource message representing a Google Analytics account.
  &quot;countryCode&quot;: &quot;A String&quot;, # Country of business. Must be a non-deprecated code for a UN M.49 region. https: //unicode.org/cldr/charts/latest/supplem // ental/territory_containment_un_m_49.html
  &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this account was originally created.
  &quot;deleted&quot;: True or False, # Output only. Indicates whether this Account is soft-deleted or not. Deleted accounts are excluded from List results unless specifically requested.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. Human-readable display name for this account.
  &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this account. Format: accounts/{account} Example: &quot;accounts/100&quot;
  &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when account payload fields were last updated.
}</pre>
</div>

<div class="method">
    <code class="details" id="provisionAccountTicket">provisionAccountTicket(body=None, x__xgafv=None)</code>
  <pre>Requests a ticket for creating an account.

Args:
  body: object, The request body.
    The object takes the form of:

{ # Request message for ProvisionAccountTicket RPC.
  &quot;account&quot;: { # A resource message representing a Google Analytics account. # The account to create.
    &quot;countryCode&quot;: &quot;A String&quot;, # Country of business. Must be a non-deprecated code for a UN M.49 region. https: //unicode.org/cldr/charts/latest/supplem // ental/territory_containment_un_m_49.html
    &quot;createTime&quot;: &quot;A String&quot;, # Output only. Time when this account was originally created.
    &quot;deleted&quot;: True or False, # Output only. Indicates whether this Account is soft-deleted or not. Deleted accounts are excluded from List results unless specifically requested.
    &quot;displayName&quot;: &quot;A String&quot;, # Required. Human-readable display name for this account.
    &quot;name&quot;: &quot;A String&quot;, # Output only. Resource name of this account. Format: accounts/{account} Example: &quot;accounts/100&quot;
    &quot;updateTime&quot;: &quot;A String&quot;, # Output only. Time when account payload fields were last updated.
  },
  &quot;redirectUri&quot;: &quot;A String&quot;, # Redirect URI where the user will be sent after accepting Terms of Service. Must be configured in Developers Console as a Redirect URI
}

  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 ProvisionAccountTicket RPC.
  &quot;accountTicketId&quot;: &quot;A String&quot;, # The param to be passed in the ToS link.
}</pre>
</div>

</body></html>