Diese Seite wurde von der Cloud Translation API übersetzt.

Konten erstellen

Mit der Merchant API können Sie Merchant Center-Konten erstellen, die über accountAggregation, accountManagement oder comparisonShopping mit einem erweiterten Konto verknüpft werden können. Mit der Methode accounts.createAndConfigure können Sie ein Konto erstellen und optional Nutzer konfigurieren und es über Dienste mit anderen Konten verknüpfen.

In diesem Leitfaden wird erläutert, wie Sie mit der Merchant API Konten über Dienste wie accountManagement, comparisonShopping oder accountAggregation erstellen. Wenn Sie accounts.createAndConfigure verwenden, müssen Sie das neue Konto mit einem Anbieter verknüpfen, indem Sie mindestens einen der Werte accountAggregation, accountManagement oder comparisonShopping im Feld service angeben. Sie können accountAggregation und comparisonShopping im selben Request angeben, accountManagement kann jedoch nicht mit accountAggregation oder comparisonShopping kombiniert werden. Wenn Sie accountManagement angeben, müssen Sie dem neuen Konto auch mindestens einen Nutzer über das Feld user oder users hinzufügen.

Vorbereitung

Bevor Sie Konten mit der Merchant API erstellen können, müssen Sie je nach den von Ihnen verwendeten Diensten die folgenden Anforderungen erfüllen:

Administratorzugriff: Sie benötigen Administratorzugriff auf das Anbieterkonto, wenn Sie ein neues Konto über accountManagement, comparisonShopping oder accountAggregation verknüpfen.
Erweitertes Konto: Wenn Sie accountAggregation verwenden, muss Ihr Anbieterkonto ein erweitertes Konto sein, das für die Kontoaggregation konfiguriert ist. Wenn Sie ein Dienstanbieter sind und ein erweitertes Konto einrichten müssen, wenden Sie sich an den Support, um Hilfe bei der Konfiguration zu erhalten.

Konto erstellen (über die Kontoverwaltung oder ein Preisvergleichsportal)

Rufen Sie accounts.createAndConfigure auf, um ein neues Konto zu erstellen. Dies ist der empfohlene Ansatz für Partner, die Händlern bei der Verwaltung ihrer Konten helfen, da Händler so die vollständige Kontrolle und das Eigentum an ihrem Konto behalten und gleichzeitig Partnern bestimmte Berechtigungen erteilen können.

Im Anfragetext:

Geben Sie die Details des Kontos, das Sie erstellen möchten, im Feld account an.
Wenn Sie accountManagement verwenden, geben Sie im Feld user mindestens einen Nutzer an, der Zugriff auf das Konto hat.
Geben Sie im Feld service alle Dienste an, die Sie für dieses Konto bereitstellen möchten, z. B. accountManagement, und legen Sie provider auf den Ressourcennamen Ihres Kontos fest (z. B. providers/{YOUR_ACCOUNT_ID}). Eine Liste der verfügbaren Dienste wie productsManagement oder campaignsManagement finden Sie unter Kontobeziehungen verwalten.

Hier sehen Sie ein Beispiel für eine Anfrage zum Erstellen eines Kontos mit dem Namen „merchantStore“ und zum Verknüpfen dieses Kontos mit dem Konto {YOUR_ACCOUNT_ID} für die Konto- und Produktverwaltung:

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "user": [
    {
      "userId": "test@example.com",
      "user": {
        "accessRights": ["ADMIN"]
      }
    }
  ],
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    },
    {
      "productsManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ]
}

Bei einem erfolgreichen Aufruf wird das neue Konto erstellt und mit Ihrem Konto für die angegebenen Dienste verknüpft. Wenn Sie bei der Erstellung die Dienste accountManagement, accountAggregation oder comparisonShopping angeben, werden sie automatisch genehmigt und der Verknüpfungsstatus ist ESTABLISHED. Andere Dienstverknüpfungen haben möglicherweise den Status PENDING, bis sie vom erstellten Konto akzeptiert werden. Der Antworttext enthält die neu erstellte Account-Ressource.

Nachdem Sie ein solches Konto erstellt haben, müssen Sie es einrichten. Dazu sind Schritte wie das Akzeptieren der Nutzungsbedingungen, das Einrichten von Unternehmensinformationen und die Bestätigung der Website erforderlich.

E-Mail-Bestätigung bei der Kontoerstellung unterdrücken

Wenn Sie ein Konto mit accounts.createAndConfigure erstellen, können Sie optional Bestätigungs-E-Mails für neue Nutzer unterdrücken, die über das Feld user hinzugefügt wurden. Dazu müssen Sie verificationMailSettings.verificationMailMode im Antrag für diesen Nutzer auf SUPPRESS_VERIFICATION_MAIL festlegen. Dies ist nützlich, wenn Sie Nutzer im Namen des Händlers sofort nach der Erstellung mit der Methode users.verifySelf bestätigen möchten. Standardmäßig ist verificationMailMode auf SEND_VERIFICATION_MAIL festgelegt und Bestätigungs-E-Mails werden an neue Nutzer gesendet, die beim Erstellen des Kontos hinzugefügt werden.

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "user": [
    {
      "userId": "test@example.com",
      "user": {
        "accessRights": ["ADMIN"]
      },
      "verificationMailSettings": {
        "verificationMailMode": "SUPPRESS_VERIFICATION_MAIL"
      }
    }
  ],
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ]
}

Wenn Sie verificationMailMode auf SUPPRESS_VERIFICATION_MAIL festlegen, müssen Sie users.verifySelf für jeden Nutzer aufrufen, der während der Erstellung hinzugefügt wurde, um die Bestätigung abzuschließen. Dieser Aufruf muss als der zu überprüfende Nutzer authentifiziert werden (der Nutzer, der in userId angegeben ist), z. B. mit einem OAuth-Token des Nutzers.

Alias bei der Kontoerstellung angeben

Sie können einen Alias für ein Konto im Kontext eines Anbieters in CreateAndConfigureAccountRequest mit dem Feld setAlias angeben. Der Alias kann verwendet werden, um das Konto in Ihrem System zu identifizieren. Wenn Sie ein Dienstanbieter sind, können Sie das Konto mit dem Alias über GET /accounts/v1/accounts/{provider}~{alias} abrufen. Der Alias muss für einen bestimmten Anbieter eindeutig sein. Sie müssen im Feld service der Anfrage einen Dienst mit demselben Anbieter angeben. Weitere Informationen zu Aliasanforderungen finden Sie unter Kontobeziehungen verwalten.

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountManagement": {},
      "provider": "providers/{YOUR_ACCOUNT_ID}"
    }
  ],
  "setAlias": [
    {
      "provider": "providers/{YOUR_ACCOUNT_ID}",
      "accountIdAlias": "my-merchant-alias"
    }
  ]
}

Empfohlener Onboarding-Ablauf

Wenn Sie als Partner ein Konto im Namen eines Händlers erstellen, empfehlen wir den folgenden Ablauf:

Konto erstellen: Rufen Sie accounts.createAndConfigure mit Ihren Partneranmeldedaten auf, um ein neues Konto zu erstellen.
- Legen Sie service so fest, dass accountManagement mit einem Link zu Ihrer Anbieter-ID enthalten ist.
- Fügen Sie den Händler als Nutzer über das Feld user hinzu und legen Sie verificationMailSettings.verificationMailMode auf SUPPRESS_VERIFICATION_MAIL fest.
Nutzer bestätigen: Rufen Sie mit den Anmeldedaten des Händlers (z. B. mit einem OAuth-Token) users.verifySelf auf, um den Nutzerstatus von PENDING zu VERIFIED zu ändern.
Land des Unternehmens festlegen: Legen Sie mit Händleranmeldedaten das Land des Unternehmens fest, indem Sie address.regionCode mit accounts.updateBusinessInfo aktualisieren. Dies ist erforderlich, bevor Sie die Nutzungsbedingungen akzeptieren können.
Nutzungsbedingungen akzeptieren: Akzeptieren Sie die Nutzungsbedingungen mit Händleranmeldedaten.

So kann ein Händler nahtlos in Ihre Plattform eingebunden werden, ohne Einladungs-E‑Mails von Google zu erhalten.

Kundenkonto erstellen (mit Kontoaggregation)

Kundenkonten sind separate Merchant Center-Konten, die über den accountAggregation-Dienst mit Ihrem erweiterten Konto verknüpft sind. So können Sie sie zentral verwalten, während Einstellungen, Websites und Datenfeeds separat bleiben. Mit der Unter-API für Händlerkonten können Sie neue Kundenkonten erstellen.

Wenn Sie Kundenkonten erstellen möchten, müssen Sie zuerst ein erweitertes Konto einrichten. Sie müssen Kontoadministrator sein, um Ihr Merchant Center-Konto in ein erweitertes Konto umzuwandeln. Außerdem dürfen in Ihrem Konto keine Probleme ausstehen.

Wenn Sie ein neues Kundenkonto erstellen möchten, rufen Sie accounts.createAndConfigure auf. Im Anfragetext:

Geben Sie die Details des Kontos, das Sie erstellen möchten, im Feld account an.
Geben Sie optional neue autorisierte Nutzer im Feld user an. Der Nutzerzugriff für das Konto wird auch vom übergeordneten erweiterten Konto übernommen.
Geben Sie im Feld service accountAggregation an und legen Sie provider auf den Ressourcennamen Ihres erweiterten Kontos fest (z. B. providers/{ADVANCED_ACCOUNT_ID}). Dadurch wird Ihr erweitertes Konto als Aggregator für das neue Konto festgelegt.

Hier sehen Sie eine Beispielanfrage zum Erstellen eines Kundenkontos mit dem Namen „merchantStore“, das mit dem erweiterten Konto {ADVANCED_ACCOUNT_ID} verknüpft ist:

POST https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure

{
  "account": {
    "accountName": "merchantStore",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountAggregation": {},
      "provider": "providers/{ADVANCED_ACCOUNT_ID}"
    }
  ]
}

Bei einem erfolgreichen Aufruf wird das neue Kundenkonto erstellt und mit Ihrem angegebenen erweiterten Konto verknüpft. Der Antworttext enthält die neu erstellte Account-Ressource.

In den folgenden Beispielen wird gezeigt, wie Sie mit der Methode accounts.createAndConfigure ein neues Kundenkonto erstellen.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.Account;
import com.google.shopping.merchant.accounts.v1.AccountAggregation;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.CreateAndConfigureAccountRequest;
import com.google.shopping.merchant.accounts.v1.CreateAndConfigureAccountRequest.AddAccountService;
import com.google.type.TimeZone;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to create a sub-account under an advanced account. */
public class CreateSubAccountSample {

  private static String getParent(String accountId) {
    return String.format("accounts/%s", accountId);
  }

  public static void createSubAccount(Config config) throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    AccountsServiceSettings accountsServiceSettings =
        AccountsServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates parent/provider to identify the advanced account into which to insert the subaccount.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {

      CreateAndConfigureAccountRequest request =
          CreateAndConfigureAccountRequest.newBuilder()
              .setAccount(
                  Account.newBuilder()
                      .setAccountName("Demo Business")
                      .setAdultContent(false)
                      .setTimeZone(TimeZone.newBuilder().setId("America/New_York").build())
                      .setLanguageCode("en-US")
                      .build())
              .addService(
                  AddAccountService.newBuilder()
                      .setProvider(parent)
                      .setAccountAggregation(AccountAggregation.getDefaultInstance())
                      .build())
              .build();

      System.out.println("Sending Create SubAccount request");
      Account response = accountsServiceClient.createAndConfigureAccount(request);
      System.out.println("Inserted Account Name below");
      // Format: `accounts/{account}
      System.out.println(response.getName());
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();

    createSubAccount(config);
  }
}CreateSubAccountSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Account;
use Google\Shopping\Merchant\Accounts\V1\AccountAggregation;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\CreateAndConfigureAccountRequest;
use Google\Shopping\Merchant\Accounts\V1\CreateAndConfigureAccountRequest\AddAccountService;
use Google\Type\TimeZone;

/**
 * This class demonstrates how to create a sub-account under an MCA account.
 */
class CreateSubAccount
{

    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }


    public static function createSubAccount(array $config): void
    {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates options config containing credentials for the client to use.
        $options = ['credentials' => $credentials];

        // Creates a client.
        $accountsServiceClient = new AccountsServiceClient($options);

        // Creates parent/provider to identify the MCA account into which to insert the subaccount.
        $parent = self::getParent($config['accountId']);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $request = new CreateAndConfigureAccountRequest([
                'account' => (new Account([
                    'account_name' => 'Demo Business',
                    'adult_content' => false,
                    'time_zone' => (new TimeZone(['id' => 'America/New_York'])),
                    'language_code' => 'en-US',
                ])),
                'service' => [
                    (new AddAccountService([
                        'provider' => $parent,
                        'account_aggregation' => new AccountAggregation,
                    ])),
                ],
            ]);

            print "Sending Create SubAccount request\n";
            $response = $accountsServiceClient->createAndConfigureAccount($request);
            print "Inserted Account Name below\n";
            // Format: `accounts/{account}
            print $response->getName() . PHP_EOL;
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }
    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::createSubAccount($config);
    }
}

$sample = new CreateSubAccount();
$sample->callSample();CreateSubAccountSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import Account
from google.shopping.merchant_accounts_v1 import AccountAggregation
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import CreateAndConfigureAccountRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


def get_parent(account_id):
  return f"accounts/{account_id}"


def create_sub_account():
  """Creates a sub-account under an advanced account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Get the parent advanced account ID.
  parent = get_parent(_ACCOUNT)

  # Create the request.
  request = CreateAndConfigureAccountRequest(
      account=Account(
          account_name="Demo Business",
          adult_content=False,
          time_zone={"id": "America/New_York"},
          language_code="en-US",
      ),
      service=[
          CreateAndConfigureAccountRequest.AddAccountService(
              provider=parent,
              account_aggregation=AccountAggregation(),
          )
      ],
  )

  # Make the request and print the response.
  try:
    print("Sending Create SubAccount request")
    response = client.create_and_configure_account(request=request)
    print("Inserted Account Name below")
    print(response.name)
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  create_sub_account()
create_sub_account_sample.py

cURL

curl -X POST \
"https://merchantapi.googleapis.com/accounts/v1/accounts:createAndConfigure" \
-H "Authorization: Bearer <YOUR_ACCESS_TOKEN>" \
-H "Content-Type: application/json" \
-d '{
  "account": {
    "accountName": "Demo Business",
    "adultContent": false,
    "timeZone": {
      "id": "America/New_York"
    },
    "languageCode": "en-US"
  },
  "service": [
    {
      "accountAggregation": {},
      "provider": "providers/{ADVANCED_ACCOUNT_ID}"
    }
  ]
}'

Kundenkonten abrufen

Verwenden Sie die Methode accounts.listSubaccounts, um alle Kundenkonten eines bestimmten erweiterten Kontos aufzulisten. Geben Sie die ID Ihres erweiterten Kontos im Feld provider der Anfrage-URL an.

Hier ein Beispiel für eine Anfrage:

GET https://merchantapi.googleapis.com/accounts/v1/accounts/{ADVANCED_ACCOUNT_ID}:listSubaccounts

Hier ist eine Beispielantwort für einen erfolgreichen Aufruf:

{
"accounts": [
    {
      "name": "accounts/<var class=\"readonly\">{SUB_ACCOUNT_ID_1}</var>",
      "accountId": "<var class=\"readonly\">{SUB_ACCOUNT_ID_1}</var>",
      "accountName": "<var class=\"readonly\">{SUB_ACCOUNT_NAME_1}</var>",
      "timeZone": {
        "id": "America/Los_Angeles"
      },
      "languageCode": "en-US"
    },
    {
      "name": "accounts/<var class=\"readonly\">{SUB_ACCOUNT_ID_2}</var>",
      "accountId": "<var class=\"readonly\">{SUB_ACCOUNT_ID_2}</var>",
      "accountName": "<var class=\"readonly\">{SUB_ACCOUNT_NAME_2}</var>",
      "timeZone": {
        "id": "America/Los_Angeles"
      },
      "languageCode": "en-US"
    }
  ]
}

Die folgenden Beispiele zeigen, wie Sie alle Kundenkonten Ihres erweiterten Kontos auflisten.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.Account;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient.ListSubAccountsPagedResponse;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.ListSubAccountsRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to list all the subaccounts of an advanced account. */
public class ListSubAccountsSample {

  private static String getParent(String accountId) {
    return String.format("accounts/%s", accountId);
  }

  public static void listSubAccounts(Config config) throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    AccountsServiceSettings accountsServiceSettings =
        AccountsServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates parent/provider to identify the advanced account from which to list all sub-accounts.
    String parent = getParent(config.getAccountId().toString());

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {

      // The parent has the format: accounts/{account}
      ListSubAccountsRequest request =
          ListSubAccountsRequest.newBuilder().setProvider(parent).build();
      System.out.println("Sending list subaccounts request:");

      ListSubAccountsPagedResponse response = accountsServiceClient.listSubAccounts(request);

      int count = 0;

      // Iterates over all rows in all pages and prints the datasource in each row.
      // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
      for (Account account : response.iterateAll()) {
        System.out.println(account);
        count++;
      }
      System.out.print("The following count of accounts were returned: ");
      System.out.println(count);
    } catch (Exception e) {
      System.out.println("An error has occured: ");
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    listSubAccounts(config);
  }
}ListSubAccountsSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\ListSubAccountsRequest;

/**
 * This class demonstrates how to list all the subaccounts of an advanced account.
 */
class ListSubAccounts
{
    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }


    public static function listSubAccounts(array $config): void
    {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates options config containing credentials for the client to use.
        $options = ['credentials' => $credentials];

        // Creates a client.
        $accountsServiceClient = new AccountsServiceClient($options);

        // Creates parent/provider to identify the advanced account from which
        //to list all accounts.
        $parent = self::getParent($config['accountId']);

        // Calls the API and catches and prints any network failures/errors.
        try {

            // The parent has the format: accounts/{account}
            $request = new ListSubAccountsRequest(['provider' => $parent]);
            print "Sending list subaccounts request:\n";

            $response = $accountsServiceClient->listSubAccounts($request);

            $count = 0;

            // Iterates over all rows in all pages and prints the datasource in each row.
            // Automatically uses the `nextPageToken` if returned to fetch all pages of data.
            foreach ($response->iterateAllElements() as $account) {
                print_r($account);
                $count++;
            }
            print "The following count of accounts were returned: ";
            print $count . PHP_EOL;
        } catch (ApiException $e) {
            print "An error has occured: \n";
            print $e->getMessage();
        }
    }

    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::listSubAccounts($config);
    }
}

$sample = new ListSubAccounts();
$sample->callSample();ListSubAccountsSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import ListSubAccountsRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


def get_parent(account_id):
  return f"accounts/{account_id}"


def list_sub_accounts():
  """Lists all the subaccounts of an advanced account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Get the parent advanced account ID.
  parent = get_parent(_ACCOUNT)

  # Create the request.
  request = ListSubAccountsRequest(provider=parent)

  # Make the request and print the response.
  try:
    print("Sending list subaccounts request:")
    response = client.list_sub_accounts(request=request)

    count = 0
    for account in response:
      print(account)
      count += 1

    print(f"The following count of accounts were returned: {count}")

  except RuntimeError as e:
    print("An error has occured: ")
    print(e)


if __name__ == "__main__":
  list_sub_accounts()
list_sub_accounts_sample.py

cURL

curl -X GET \
"https://merchantapi.googleapis.com/accounts/v1/accounts/{ADVANCED_ACCOUNT_ID}:listSubaccounts" \
-H "Authorization: Bearer <YOUR_ACCESS_TOKEN>"

Kundenkonto löschen

Wenn Sie ein Kundenkonto nicht mehr verwalten müssen, können Sie es mit der Methode accounts.delete löschen.

Für die Ausführung dieser Methode ist Administratorzugriff auf das zu löschende Konto erforderlich.

Hier ein Beispiel für eine Anfrage:

DELETE https://merchantapi.googleapis.com/accounts/v1/accounts/{SUB_ACCOUNT_ID}

Wenn der Vorgang erfolgreich ist, ist der Antworttext ein leeres JSON-Objekt, das angibt, dass das Konto gelöscht wurde.

Die folgenden Beispiele zeigen, wie Sie ein Kundenkonto löschen.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.shopping.merchant.accounts.v1.AccountName;
import com.google.shopping.merchant.accounts.v1.AccountsServiceClient;
import com.google.shopping.merchant.accounts.v1.AccountsServiceSettings;
import com.google.shopping.merchant.accounts.v1.DeleteAccountRequest;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to delete a given Merchant Center account. */
public class DeleteAccountSample {

  // This method can delete a standalone, advanced account or sub-account. If you delete an advanced
  // account,
  // all sub-accounts will also be deleted.
  // Admin user access is required to execute this method.

  public static void deleteAccount(Config config) throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    AccountsServiceSettings accountsServiceSettings =
        AccountsServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Gets the account ID from the config file.
    String accountId = config.getAccountId().toString();

    // Creates account name to identify the account.
    String name =
        AccountName.newBuilder()
            .setAccount(accountId)
            .build()
            .toString();

    // Calls the API and catches and prints any network failures/errors.
    try (AccountsServiceClient accountsServiceClient =
        AccountsServiceClient.create(accountsServiceSettings)) {
      DeleteAccountRequest request =
          DeleteAccountRequest.newBuilder()
              .setName(name)
              // Optional. If set to true, the account will be deleted even if it has offers or
              // provides services to other accounts. Defaults to 'false'.
              .setForce(true)
              .build();

      System.out.println("Sending Delete Account request");
      accountsServiceClient.deleteAccount(request); // No response returned on success.
      System.out.println("Delete successful.");
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    deleteAccount(config);
  }
}DeleteAccountSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Shopping\Merchant\Accounts\V1\Client\AccountsServiceClient;
use Google\Shopping\Merchant\Accounts\V1\DeleteAccountRequest;


/**
 * This class demonstrates how to delete a given Merchant Center account.
 */
class DeleteAccount
{
    private static function getParent(string $accountId): string
    {
        return sprintf("accounts/%s", $accountId);
    }

    // This method can delete a standalone, advanced account or sub-account.
    // If you delete an advanced account, all sub-accounts will also be deleted.
    // Admin user access is required to execute this method.
    public static function deleteAccount(array $config): void
    {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates options config containing credentials for the client to use.
        $options = ['credentials' => $credentials];

        // Creates a client.
        $accountsServiceClient = new AccountsServiceClient($options);


        // Gets the account ID from the config file.
        $accountId = $config['accountId'];

        // Creates account name to identify the account.
        $name = self::getParent($accountId);

        // Calls the API and catches and prints any network failures/errors.
        try {
            $request = new DeleteAccountRequest([
                'name' => $name,
                // Optional. If set to true, the account will be deleted even if it has offers or
                // provides services to other accounts. Defaults to 'false'.
                'force' => true,
            ]);

            print "Sending Delete Account request\n";
            $accountsServiceClient->deleteAccount($request); // No response returned on success.
            print "Delete successful.\n";
        } catch (ApiException $e) {
            print $e->getMessage();
        }
    }

    public function callSample(): void
    {
        $config = Config::generateConfig();
        self::deleteAccount($config);
    }
}

$sample = new DeleteAccount();
$sample->callSample();DeleteAccountSample.php

Python

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.shopping.merchant_accounts_v1 import AccountsServiceClient
from google.shopping.merchant_accounts_v1 import DeleteAccountRequest

_ACCOUNT = configuration.Configuration().read_merchant_info()


def get_parent(account_id):
  return f"accounts/{account_id}"


def delete_account():
  """Deletes a given Merchant Center account."""

  # Get OAuth credentials.
  credentials = generate_user_credentials.main()

  # Create a client.
  client = AccountsServiceClient(credentials=credentials)

  # Create the account name.
  name = get_parent(_ACCOUNT)

  # Create the request.
  request = DeleteAccountRequest(name=name, force=True)

  # Make the request and print the response.
  try:
    print("Sending Delete Account request")
    client.delete_account(request=request)
    print("Delete successful.")
  except RuntimeError as e:
    print(e)


if __name__ == "__main__":
  delete_account()
delete_account_sample.py

cURL

curl -X DELETE \
"https://merchantapi.googleapis.com/accounts/v1/accounts/{SUB_ACCOUNT_ID}?force=true" \
-H "Authorization: Bearer <YOUR_ACCESS_TOKEN>"

Nutzungsbedingungen akzeptieren

Für Kundenkonten gelten die Merchant Center-Nutzungsbedingungen, die für das übergeordnete erweiterte Konto unterzeichnet wurden.

Informationen zum Unternehmen aktualisieren

Mit der Merchant Accounts API können Sie die Unternehmensinformationen für Ihre Kundenkonten bearbeiten.

Rufen Sie accounts.getBusinessInfo auf, um die Unternehmensinformationen eines Kontos aufzurufen.
- Rufen Sie accounts.updateBusinessInfo auf, um die Informationen zum Unternehmen eines Kontos zu bearbeiten.

Zurück

Overview

Weiter

Manage Terms of Service

Konten erstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Vorbereitung

Konto erstellen (über die Kontoverwaltung oder ein Preisvergleichsportal)

E-Mail-Bestätigung bei der Kontoerstellung unterdrücken

Alias bei der Kontoerstellung angeben

Empfohlener Onboarding-Ablauf

Kundenkonto erstellen (mit Kontoaggregation)

Java

PHP

Python

cURL

Kundenkonten abrufen

Java

PHP

Python

cURL

Kundenkonto löschen

Java

PHP

Python

cURL

Nutzungsbedingungen akzeptieren

Informationen zum Unternehmen aktualisieren

Konten erstellen