En esta página, se muestra cómo crear y actualizar de forma programática tus fuentes de datos que te permiten insertar productos. Las fuentes de datos automáticas facilitan el envío de tus datos de productos a Google. Las fuentes de datos automáticas se aseguran de que la información más actualizada sobre los productos relevantes de tu sitio web llegue a Google.
Content API for Shopping solo te permite crear fuentes de datos principales. Con la API de Merchant Data Sources, puedes crear los siguientes tipos de fuentes de datos:
- Fuentes de datos de productos principales
- Fuentes de datos de productos complementarias
- Fuentes de datos del inventario local
- Fuentes de datos de inventario regionales
- Fuentes de datos de promociones
- Fuentes de datos de opiniones sobre productos
- Fuentes de datos de opiniones sobre comercios
Content API for Shopping solo te permite administrar fuentes de datos con entrada de archivos. La API de Merchant te permite administrar fuentes de datos con entradas de archivos y de API.
Con la API de Merchant Data Sources, puedes hacer lo siguiente:
- Crea una nueva fuente de datos principal con un
feedLabely uncontentLanguageespecíficos. - Crea una fuente de datos que no tenga configurados los campos
feedLabelycontentLanguage. Con este tipo de fuente de datos, puedes segmentar tus productos para varios países, ya que puedes insertar productos con diferentes combinaciones defeedLabelycontentLanguageen una sola fuente de datos. - Crea una fuente de datos complementaria para vincularla a una fuente de datos principal existente.
- Configura una programación para una fuente de datos de archivos.
- Inscribe tu cuenta para administrar automáticamente las fuentes de datos.
- Administra fuentes de datos de la API.
- Administra la regla predeterminada de las fuentes de datos con fuentes de datos de productos principales.
- Usa otros tipos de fuentes de datos, como las promociones.
No puedes usar la API de Merchant Center para insertar productos en una fuente de datos que contenga productos locales y en línea. Para obtener más información sobre los canales de fuentes de datos, consulta Canales.
Requisitos previos
- Tu cuenta se debe haber migrado a feeds de configuración regional única.
Para verificar que la cuenta ya se haya migrado a la división de objetivos de datos, usa la lista de fuentes de datos o los métodos get. En caso de que no cumplas con los requisitos, recibirás el siguiente mensaje de excepción y deberás comunicarte con el equipo de asistencia.
This account is in the data sources migration process and can't be used with this API yet. Contact support for more info on when this account will be able to use the data sources endpoint.
Crea una fuente de datos nueva
Las fuentes de datos principales son las fuentes de datos principales de tu inventario de Merchant Center. Solo puedes agregar o quitar productos con una fuente de datos principal. Si todos los productos que agregas a tu fuente de datos principal cumplen con los requisitos de datos y de elegibilidad de Merchant Center, no será necesario que crees más fuentes de datos.
Para crear una nueva fuente de datos principal con un feedLabel y un contentLanguage específicos, configura los campos feedLabel y contentLanguage en la configuración específica del tipo. Para obtener más información sobre estos campos, consulta PrimaryProductDataSource.
En la siguiente solicitud de ejemplo, se muestra cómo puedes crear una fuente de datos de productos principales:
POST https://merchantapi.googleapis.com/datasources/v1beta/accounts/{ACCOUNT_ID}/dataSources
{
"displayName": "{DISPLAY_NAME}",
"primaryProductDataSource": {
"contentLanguage": "{CONTENT_LANGUAGE}",
"feedLabel": "{FEED_LABEL}",
"countries": [
"{COUNTRY}"
],
"channel": "ONLINE_PRODUCTS"
}
}
Reemplaza lo siguiente:
- {ACCOUNT_ID}: Es el identificador único de tu cuenta de Merchant Center.
- {DISPLAY_NAME}: Es el nombre visible de la fuente de datos.
- {CONTENT_LANGUAGE}: Es el código de idioma ISO 639-1 de dos letras de los productos en la fuente de datos.
- {FEED_LABEL}: Es la etiqueta del feed de la fuente de datos.
- {COUNTRY}: Es el código de territorio CLDR del país de destino de los productos que se subirán con la fuente de datos.
Después de que se ejecute correctamente la solicitud, verás la siguiente respuesta:
{
"name": "accounts/{ACCOUNT_ID}/dataSources/{DATASOURCE_ID}",
"dataSourceId": "{DATASOURCE_ID}",
"displayName": "{DISPLAY_NAME}",
"primaryProductDataSource": {
"channel": "ONLINE_PRODUCTS",
"feedLabel": "{FEED_LABEL}",
"contentLanguage": "{CONTENT_LANGUAGE}",
"countries": [
"{COUNTRY}"
],
"defaultRule": {
"takeFromDataSources": [
{
"self": true
}
]
}
},
"input": "API"
}
Para obtener más información sobre cómo crear una fuente de datos, consulta el método accounts.dataSources.create.
Para ver la fuente de datos que acabas de crear, usa el método accounts.dataSources.get o accounts.dataSources.list.
En el siguiente ejemplo, se muestra cómo puedes crear una fuente de datos de productos principales para la combinación GB y en feedLabel y contentLanguage.
Java
public static String createDataSource(Config config, String displayName) throws Exception {
GoogleCredentials credential = new Authenticator().authenticate();
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
String parent = getParent(config.getAccountId().toString());
// The type of data that this datasource will receive.
PrimaryProductDataSource primaryProductDataSource =
PrimaryProductDataSource.newBuilder()
// Channel can be "ONLINE_PRODUCTS" or "LOCAL_PRODUCTS" or "PRODUCTS" .
// While accepted, datasources with channel "products" representing unified products
// currently cannot be used with the Products bundle.
.setChannel(PrimaryProductDataSource.Channel.ONLINE_PRODUCTS)
.addCountries("GB")
.build();
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
CreateDataSourceRequest request =
CreateDataSourceRequest.newBuilder()
.setParent(parent)
.setDataSource(
DataSource.newBuilder()
.setDisplayName(displayName)
.setPrimaryProductDataSource(primaryProductDataSource)
.build())
.build();
System.out.println("Sending Create PrimaryProduct DataSource request");
DataSource response = dataSourcesServiceClient.createDataSource(request);
System.out.println("Created DataSource Name below");
System.out.println(response.getName());
return response.getName();
} catch (Exception e) {
System.out.println(e);
System.exit(1);
// Null is necessary to satisfy the compiler as we're not returning a String on failure.
return null;
}
}
Crea una nueva fuente de datos principal que te ayude a segmentar los anuncios para varios países
Para crear un nuevo feed principal que te ayude a segmentar tus anuncios para varios países, configura tu fuente de datos con PrimaryProductDataSource y no configures los campos feedLabel y contentLanguage.
Con Content API for Shopping, solo se crea una fuente de datos de API para ti. Con la API de Merchant Data Sources, puedes tener varias fuentes de datos de API, algunas de las cuales pueden no tener configurados los campos feedLabel y contentLanguage.
Solo las fuentes de datos con entrada de API pueden estar sin los campos feedLabel y contentLanguage configurados. Este tipo de fuentes de datos no es compatible con las entradas de archivo.
Crea una fuente de datos complementaria y vincúlala a la fuente de datos principal
Las fuentes de datos complementarias solo se usan para actualizar los datos de productos que ya existen en una o más fuentes de datos principales. Puedes tener varias fuentes de datos complementarias, y cada una puede agregar datos a cualquier cantidad de fuentes de datos principales.
Puedes usar fuentes de datos complementarias para realizar actualizaciones parciales de los datos de productos. Para ello, agrega el identificador único de la fuente de datos como un parámetro de consulta cuando realices llamadas a los métodos accounts.productInputs.insert y accounts.productInputs.delete. Solo puedes usar fuentes de datos complementarias para actualizar productos existentes.
Para crear una fuente de datos complementaria, configúrala con SupplementalProductDataSource y, luego, vincúlala actualizando el campo defaultRule en tu fuente de datos principal.
Las fuentes de datos de archivos complementarios deben tener establecidos los campos feedLabel y contentLanguage. Las fuentes de datos de la API complementarias siempre deben tener los campos feedLabel y contentLanguage sin definir.
En el siguiente ejemplo, se muestra cómo puedes crear una fuente de datos de productos complementarios de archivos para la combinación de en y GB contentLanguage y feedLabel.
Java
private static FileInput setFileInput() {
// If FetchSettings are not set, then this will be an `UPLOAD` file type
// that you must manually upload via the Merchant Center UI.
return FileInput.newBuilder()
// FileName is required for `UPLOAD` fileInput type.
.setFileName("British T-shirts Supplemental Data")
.build();
}
public static String createDataSource(Config config, String displayName, FileInput fileInput)
throws Exception {
GoogleCredentials credential = new Authenticator().authenticate();
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
String parent = getParent(config.getAccountId().toString());
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
CreateDataSourceRequest request =
CreateDataSourceRequest.newBuilder()
.setParent(parent)
.setDataSource(
DataSource.newBuilder()
.setDisplayName(displayName)
.setSupplementalProductDataSource(
SupplementalProductDataSource.newBuilder()
.setContentLanguage("en")
.setFeedLabel("GB")
.build())
.setFileInput(fileInput)
.build())
.build();
System.out.println("Sending create SupplementalProduct DataSource request");
DataSource response = dataSourcesServiceClient.createDataSource(request);
System.out.println("Created DataSource Name below");
System.out.println(response.getName());
return response.getName();
} catch (Exception e) {
System.out.println(e);
System.exit(1);
// Null is necessary to satisfy the compiler as we're not returning a String on failure.
return null;
}
}
Para crear una fuente de datos complementaria que funcione para todas las combinaciones de feedLabel y contentLanguage, ejecuta el siguiente ejemplo.
Java
public static String createDataSource(Config config, String displayName) throws Exception {
GoogleCredentials credential = new Authenticator().authenticate();
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
String parent = getParent(config.getAccountId().toString());
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
CreateDataSourceRequest request =
CreateDataSourceRequest.newBuilder()
.setParent(parent)
.setDataSource(
DataSource.newBuilder()
.setDisplayName(displayName)
.setSupplementalProductDataSource(
SupplementalProductDataSource.newBuilder().build())
.build())
.build();
System.out.println("Sending create SupplementalProduct DataSource request");
DataSource response = dataSourcesServiceClient.createDataSource(request);
System.out.println("Created DataSource Name below");
System.out.println(response.getName());
return response.getName();
} catch (Exception e) {
System.out.println(e);
System.exit(1);
return null; // Necessary to satisfy the compiler as we're not returning a
// String on failure.
}
}
Configura una programación para tu fuente de datos de archivos
Para configurar un programa para tu feed de archivos, configura tu fuente de datos como una fuente de datos de archivo con el campo FileInput y, luego, configura fetchsettings con el campo FileInput.FetchSettings.
Cómo borrar una fuente de datos
Para borrar una fuente de datos existente de tu cuenta, usa el método accounts.dataSources.delete.
En el siguiente ejemplo, se muestra cómo puedes usar el paquete DeleteDataSourceRequest para borrar una fuente de datos.
Java
public static void deleteDataSource(Config config, String dataSourceId) throws Exception {
GoogleCredentials credential = new Authenticator().authenticate();
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
String name =
DataSourceName.newBuilder()
.setAccount(config.getAccountId().toString())
.setDatasource(dataSourceId)
.build()
.toString();
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
DeleteDataSourceRequest request = DeleteDataSourceRequest.newBuilder().setName(name).build();
System.out.println("Sending deleteDataSource request");
// Delete works for any datasource type.
// If Type "Supplemental", delete will only work if it's not linked to any primary feed.
// If a link exists and the Type is "Supplemental", you will need to remove the supplemental
// feed from the default and/or custom rule(s) of any primary feed(s) that references it. Then
// retry the delete.
dataSourcesServiceClient.deleteDataSource(request); // No response returned on success.
System.out.println(
"Delete successful, note that it may take a few minutes for the delete to update in"
+ " the system.");
} catch (Exception e) {
System.out.println(e);
}
}
Cómo recuperar la fuente de datos
Para recuperar un archivo configurado en la fuente de datos, usa el método accounts.dataSources.fetch. Este método recupera los datos de inmediato en una fuente de datos de
tu cuenta. Este método solo funciona en fuentes de datos con un conjunto de entradas de archivos.
Cómo obtener la fuente de datos
Para recuperar la configuración de la fuente de datos de tu cuenta, usa el método
accounts.dataSources.get.
En el siguiente ejemplo, se muestra cómo puedes usar el paquete GetDataSourceRequest para recuperar una fuente de datos específica de una cuenta de Merchant Center determinada.
Java
public static DataSource getDataSource(Config config, String dataSourceId) throws Exception {
// Obtains OAuth token based on the user's configuration.
GoogleCredentials credential = new Authenticator().authenticate();
// Creates service settings using the credentials retrieved above.
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
// Creates datasource name to identify datasource.
String name =
DataSourceName.newBuilder()
.setAccount(config.getAccountId().toString())
.setDatasource(dataSourceId)
.build()
.toString();
// Calls the API and catches and prints any network failures/errors.
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
// The name has the format: accounts/{account}/datasources/{datasource}
GetDataSourceRequest request = GetDataSourceRequest.newBuilder().setName(name).build();
System.out.println("Sending GET DataSource request:");
DataSource response = dataSourcesServiceClient.getDataSource(request);
System.out.println("Retrieved DataSource below");
System.out.println(response);
return response;
} catch (Exception e) {
System.out.println(e);
System.exit(1);
return null; // Necessary to satisfy the compiler as we're not returning a
// DataSource on failure.
}
}
Fuente de datos de la lista
Para enumerar las configuraciones de las fuentes de datos de tu cuenta, usa el método accounts.dataSources.list.
En el siguiente ejemplo, se muestra cómo puedes usar el paquete ListDataSourceRequest para enumerar todas las fuentes de datos de una cuenta de Merchant Center determinada.
Java
public static ArrayList<DataSource> listDataSources(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.
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
// Creates parent to identify the account from which to list all the datasources.
String parent = getParent(config.getAccountId().toString());
// Calls the API and catches and prints any network failures/errors.
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
// The parent has the format: accounts/{account}
ListDataSourcesRequest request =
ListDataSourcesRequest.newBuilder().setParent(parent).build();
System.out.println("Sending list datasources request:");
ListDataSourcesPagedResponse response = dataSourcesServiceClient.listDataSources(request);
int count = 0;
ArrayList<DataSource> dataSources = new ArrayList<DataSource>();
ArrayList<DataSource> justPrimaryDataSources = new ArrayList<DataSource>();
// 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 (DataSource element : response.iterateAll()) {
System.out.println(element);
count++;
dataSources.add(element);
// The below lines show how to filter datasources based on type.
// `element.hasSupplementalProductDataSource()` would give you supplemental
// datasources, etc.
if (element.hasPrimaryProductDataSource()) {
justPrimaryDataSources.add(element);
}
}
System.out.print("The following count of elements were returned: ");
System.out.println(count);
return dataSources;
} catch (Exception e) {
System.out.println(e);
System.exit(1);
return null; // Necessary to satisfy the compiler as we're not returning an
// ArrayList<DataSource> on failure.
}
}
Cómo aplicar parches a una fuente de datos
Para actualizar la configuración de una fuente de datos existente, usa el método accounts.dataSources.patch.
En el siguiente ejemplo, se muestra cómo puedes usar el paquete UpdateDataSourceRequest para actualizar una fuente de datos. También se muestra cómo actualizar una fuente de datos principal para agregar fuentes de datos complementarias a su regla predeterminada.
Java
public static String updateDataSource(Config config, String displayName, String dataSourceId)
throws Exception {
GoogleCredentials credential = new Authenticator().authenticate();
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
// Creates datasource name to identify datasource.
String name =
DataSourceName.newBuilder()
.setAccount(config.getAccountId().toString())
.setDatasource(dataSourceId)
.build()
.toString();
DataSource dataSource =
DataSource.newBuilder()
// Update the datasource to have the new display name
.setDisplayName(displayName)
.setName(name)
.build();
FieldMask fieldMask = FieldMask.newBuilder().addPaths("display_name").build();
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
UpdateDataSourceRequest request =
UpdateDataSourceRequest.newBuilder()
.setDataSource(dataSource)
.setUpdateMask(fieldMask)
.build();
System.out.println("Sending Update DataSource request");
DataSource response = dataSourcesServiceClient.updateDataSource(request);
System.out.println("Updated DataSource Name below");
System.out.println(response.getName());
return response.getName();
} catch (Exception e) {
System.out.println(e);
System.exit(1);
return null;
}
}
public String updateDataSource(
Config config,
String primaryDataSourceName,
String firstSupplementalDataSourceName,
String secondSupplementalDataSourceName)
throws Exception {
GoogleCredentials credential = new Authenticator().authenticate();
DataSourcesServiceSettings dataSourcesServiceSettings =
DataSourcesServiceSettings.newBuilder()
.setCredentialsProvider(FixedCredentialsProvider.create(credential))
.build();
// Setting self to 'true' refers to the primary datasource itself.
DataSourceReference dataSourceReferenceSelf =
DataSourceReference.newBuilder().setSelf(true).build();
DataSourceReference firstSupplementalDataSourceReference =
DataSourceReference.newBuilder()
.setSupplementalDataSourceName(firstSupplementalDataSourceName)
.build();
DataSourceReference secondSupplementalDataSourceReference =
DataSourceReference.newBuilder()
.setSupplementalDataSourceName(secondSupplementalDataSourceName)
.build();
// The attributes will first be taken from the primary DataSource.
// Then the first supplemental DataSource if the attribute is not in the primary DataSource
// And finally the second supplemental DataSource if not in the first two DataSources.
// Note that CustomRules could change the behavior of how updates are applied.
DefaultRule defaultRule =
DefaultRule.newBuilder()
.addTakeFromDataSources(dataSourceReferenceSelf)
.addTakeFromDataSources(firstSupplementalDataSourceReference)
.addTakeFromDataSources(secondSupplementalDataSourceReference)
.build();
// The type of data that this datasource will receive.
PrimaryProductDataSource primaryProductDataSource =
PrimaryProductDataSource.newBuilder().setDefaultRule(defaultRule).build();
DataSource dataSource =
DataSource.newBuilder()
// Update the primary datasource to have the default rule datasources in the correct
// order.
.setPrimaryProductDataSource(primaryProductDataSource)
.setName(primaryDataSourceName)
.build();
// The '.' signifies a nested field.
FieldMask fieldMask =
FieldMask.newBuilder().addPaths("primary_product_data_source.default_rule").build();
try (DataSourcesServiceClient dataSourcesServiceClient =
DataSourcesServiceClient.create(dataSourcesServiceSettings)) {
UpdateDataSourceRequest request =
UpdateDataSourceRequest.newBuilder()
.setDataSource(dataSource)
.setUpdateMask(fieldMask)
.build();
System.out.println("Sending Update DataSource request");
DataSource response = dataSourcesServiceClient.updateDataSource(request);
System.out.println("Updated DataSource Name below");
System.out.println(response.getName());
return response.getName();
} catch (Exception e) {
System.out.println(e);
System.exit(1);
return null;
}
}
Vincula fuentes de datos
Las fuentes de datos de productos principales te permiten administrar la regla predeterminada de las fuentes de datos. La regla predeterminada es la que se aplica a todos los atributos de tu fuente de datos. La regla predeterminada se puede establecer cuando se crea la fuente de datos o cuando se actualiza una fuente de datos existente a través del campo de regla predeterminada.
Para obtener más información sobre la configuración de reglas, consulta Configura reglas para tus fuentes de datos de productos.
La siguiente configuración de muestra garantiza que todos los atributos se tomen primero de la fuente de datos con el identificador único 1001. Luego, se agregan los atributos faltantes desde la fuente de datos principal. Con el tiempo, los atributos restantes se tomarán de la fuente de datos complementaria con el identificador único 1002 si aún no se proporcionaron en ninguna otra fuente de datos. Si se proporciona el mismo atributo en varias fuentes de datos, se selecciona el valor más alto de la lista.
defaultRule {
takeFromDataSources: [
'1001', // Supplemental product data source
'self', // Self reference to the primary data source
'1002' // Supplemental product data source
]
}
Administración automática de feeds
Para inscribir tu cuenta para la administración automática de fuentes de datos, debes hacer lo siguiente:
- Para verificar si tu cuenta es apta para la inscripción, llama al método
accounts.autofeedSettings.getAutofeedSettings. - Asegúrate de que tu cuenta no sea una cuenta de mercado.
Una vez que tu cuenta sea apta para la inscripción, puedes usar el método accounts.autofeedSettings.updateAutofeedSettings para habilitar la administración automática de las fuentes de datos. Si habilitas la administración automática de fuentes de datos, Google agregará automáticamente los productos de tu tienda en línea y se asegurará de que siempre estén actualizados en las plataformas de Google.
Cómo recuperar el estado de carga de un archivo
Para obtener el estado de una fuente de datos con un archivo, una recuperación o una hoja de cálculo, puedes llamar al método GET del servicio accounts.dataSources.fileUploads. Para obtener el resultado de la última recuperación de la fuente de datos calculada
de forma asíncrona cuando finaliza el procesamiento de la fuente de datos, usa el identificador de nombre
latest.
GET https://merchantapi.googleapis.com/accounts/v1beta/{ACCOUNT_ID}/datasources/{DATASOURCE_ID}/fileUploads/latest
El estado de carga de archivos puede contener una vista detallada de tus productos, incluidos posibles problemas.
Ten en cuenta que es posible que el estado de carga del archivo no exista si nunca se subió. Es posible que el estado de carga del archivo esté en procesamiento si se solicita poco después de subirlo.