API de Google Tag Manager: guía para desarrolladores

En esta guía para desarrolladores se indican los pasos necesarios para ver, crear y gestionar entidades de cuentas de Google Tag Manager a través de la API de Tag Manager v2.

Introducción

Esta guía indica cómo acceder a una cuenta de Google Tag Manager y configurarla. Al finalizar, tendrás conocimientos básicos sobre cómo hacer lo siguiente:

  • Crear un objeto de servicio de Tag Manager.
  • Autenticar y autorizar a un usuario.
  • Usar la API de Tag Manager para acceder a recursos y gestionarlos.

Antes de empezar

Antes de empezar con la guía, te recomendamos que visites estos sitios web para familiarizarte con Google Tag Manager.

  • Cómo empezar: una guía de usuario que indica cómo comenzar a utilizar Google Tag Manager.
  • Referencia de la API: obtén información sobre la interfaz de la API y las operaciones admitidas.

Usar una cuenta de prueba

Si quieres usar la API de Tag Manager para crear, configurar o eliminar entidades, te recomendamos que implementes y verifiques tu código con una cuenta de prueba. Así evitarás modificar accidentalmente tus cuentas activas. Después de haber probado y confirmado que tu código funciona del modo previsto con la cuenta de prueba, puedes implementarlo en las cuentas reales.

Elegir un lenguaje

En esta guía se tratan varios lenguajes de programación. Selecciona el lenguaje que quieras usar:

Java


En todos los fragmentos de código de esta guía se utiliza Java.

Python


En todos los fragmentos de código de esta guía se utiliza Python.

Descripción general del programa

El programa de ejemplo incluido en esta guía es una aplicación de línea de comandos. A partir de un ID de cuenta, la aplicación encuentra un contenedor llamado Saludos y crea una etiqueta de Universal Analytics dentro de él. Cuando un usuario visita hello-world.html, la etiqueta envía un hit de página vista.

Para desarrollar esta aplicación, debes seguir estos pasos:

  1. Configura el entorno y el proyecto en la consola de APIs de Google.
  2. Crea un objeto de servicio de Tag Manager.
    1. Autoriza el acceso a una cuenta de Tag Manager.
    2. Crea un objeto de servicio de Tag Manager.
  3. Consulta la API, gestiona la respuesta y envía los resultados
    1. Obtén un objeto de servicio de Tag Manager inicializado.
    2. Usa el objeto de servicio de Tag Manager para consultar la API de Tag Manager a la hora de hacer las siguientes tareas:
      1. Recuperar el contenedor de Saludos de la cuenta de Google Tag Manager autenticada.
      2. Crear la etiqueta de Universal Analytics.
      3. Crear la regla que activará la etiqueta.
      4. Actualizar la etiqueta para que la ejecute la regla.

Configurar el entorno y el proyecto

Crear el contenedor Saludos

En esta guía se da por hecho que tienes una cuenta de Google Tag Manager con un contenedor llamado Saludos. Sigue las instrucciones que se indican en el artículo Configurar e instalar Tag Manager para crear una cuenta y un contenedor llamado Saludos.

Instalar una biblioteca de cliente

Antes de empezar, instala y configura una biblioteca de cliente de las API de Google.

Crear y configurar un proyecto en la consola de APIs de Google

Para empezar a usar la API de Tag Manager, primero debes utilizar la herramienta de configuración, que te guiará por los pasos necesarios para crear un proyecto en la consola de APIs de Google, habilitar la API y crear las credenciales.

Esta guía usa un flujo de autenticación de aplicación instalada. Sigue las instrucciones que se indican más abajo para crear las credenciales del proyecto. Cuando se te solicite, selecciona el TIPO DE APLICACIÓN Installed Application y el TIPO DE APLICACIÓN INSTALADA Other.

  1. En la página Credenciales, haz clic en Crear credenciales > ID de cliente de OAuth para crear tus credenciales de OAuth 2.0 o en Crear credenciales> Clave de cuenta de servicio para crear una cuenta de servicio.
  2. Si has creado un ID de cliente de OAuth, selecciona el tipo de aplicación.
  3. Rellena el formulario y haz clic en Crear.

Las claves de la cuenta de servicio y los ID de cliente de la aplicación se mostrarán en la página Credenciales. Para obtener más detalles, haz clic en un ID de cliente; los parámetros variarán según el tipo de ID, pero podrían incluir la dirección de correo electrónico, el secreto de cliente, los orígenes de JavaScript y las URI de redirección.

Descarga los detalles del cliente haciendo clic en el botón Descargar JSON. Cambia el nombre de este archivo a client_secrets.json. Este archivo se utilizará más tarde durante la autenticación.

Crear un objeto de servicio de Tag Manager

Deberás usar el objeto service de Tag Manager para hacer solicitudes a API.

Sigue estos pasos para crear un objeto de servicio de Tag Manager:

  1. Autoriza el acceso a una cuenta de Google Tag Manager.
  2. Crea una instancia del objeto de servicio de Tag Manager.

Autorizar el acceso a una cuenta de Google Tag Manager

Cuando un usuario inicie una aplicación creada con la API de Google Tag Manager, deberá darle acceso a su cuenta de Google Tag Manager. Este proceso se llama autorización. El método recomendado para autorizar a los usuarios es OAuth 2.0. Si quieres obtener más información, consulta el artículo Configurar e instalar Tag Manager.

El código que aparece más abajo utiliza los detalles del proyecto y del cliente creados más arriba para autenticar al usuario de la aplicación y le pide permiso para acceder a Google Tag Manager en su nombre.

La aplicación intentará abrir el navegador predeterminado y mostrar al usuario una URL alojada en google.com. Se le pedirá que inicie sesión y que permita a la aplicación acceder a su cuenta de Tag Manager. Una vez concedido, la aplicación intentará leer un código de la ventana del navegador y, a continuación, la cerrará.

Nota: Si se produce algún error, la aplicación solicitará al usuario que introduzca su código de autorización en la línea de comandos.

Java

/**
 * Access and manage a Google Tag Manager account.
 */

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.tagmanager.Tagmanager;
import com.google.api.services.tagmanager.TagmanagerScopes;
import com.google.api.services.tagmanager.model.Condition;
import com.google.api.services.tagmanager.model.Container;
import com.google.api.services.tagmanager.model.Parameter;
import com.google.api.services.tagmanager.model.Rule;
import com.google.api.services.tagmanager.model.Tag;

import java.io.File;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class HelloWorld {
  // Path to client_secrets.json file downloaded from the Developer's Console.
  // The path is relative to HelloWorld.java.
  private static final String CLIENT_SECRET_JSON_RESOURCE = "client_secrets.json";

  // The directory where the user's credentials will be stored for the application.
  private static final File DATA_STORE_DIR = new File("PATH_TO_DIRECTORY");

  private static final String APPLICATION_NAME = "HelloWorld";
  private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
  private static NetHttpTransport httpTransport;
  private static FileDataStoreFactory dataStoreFactory;

  public static void main(String[] args) {
    try {
      httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      dataStoreFactory = new FileDataStoreFactory(DATA_STORE_DIR);

      // Authorization flow.
      Credential credential = authorize();
      Tagmanager manager = new Tagmanager.Builder(httpTransport, JSON_FACTORY, credential)
          .setApplicationName(APPLICATION_NAME).build();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  private static Credential authorize() throws Exception {
    // Load client secrets.
    GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY,
        new InputStreamReader(HelloWorld.class.getResourceAsStream(CLIENT_SECRET_JSON_RESOURCE)));

    // Set up authorization code flow for all auth scopes.
    GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(httpTransport,
        JSON_FACTORY, clientSecrets, TagmanagerScopes.all()).setDataStoreFactory(dataStoreFactory)
        .build();

    // Authorize.
    return new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
  }
}

    

Python

"""Access and manage a Google Tag Manager account."""

import argparse
import sys

import httplib2

from apiclient.discovery import build
from oauth2client import client
from oauth2client import file
from oauth2client import tools

def GetService(api_name, api_version, scope, client_secrets_path):
  """Get a service that communicates to a Google API.

  Args:
    api_name: string The name of the api to connect to.
    api_version: string The api version to connect to.
    scope: A list of strings representing the auth scopes to authorize for the
      connection.
    client_secrets_path: string A path to a valid client secrets file.

  Returns:
    A service that is connected to the specified API.
  """
  # Parse command-line arguments.
  parser = argparse.ArgumentParser(
      formatter_class=argparse.RawDescriptionHelpFormatter,
      parents=[tools.argparser])
  flags = parser.parse_args([])

  # Set up a Flow object to be used if we need to authenticate.
  flow = client.flow_from_clientsecrets(
      client_secrets_path, scope=scope,
      message=tools.message_if_missing(client_secrets_path))

  # Prepare credentials, and authorize HTTP object with them.
  # If the credentials don't exist or are invalid run through the native client
  # flow. The Storage object will ensure that if successful the good
  # credentials will get written back to a file.
  storage = file.Storage(api_name + '.dat')
  credentials = storage.get()
  if credentials is None or credentials.invalid:
    credentials = tools.run_flow(flow, storage, flags)
  http = credentials.authorize(http=httplib2.Http())

  # Build the service object.
  service = build(api_name, api_version, http=http)

  return service

def main(argv):
  # Define the auth scopes to request.
  scope = ['https://www.googleapis.com/auth/tagmanager.edit.containers']

  # Authenticate and construct service.
  service = GetService('tagmanager', 'v1', scope, 'client_secrets.json')

if __name__ == '__main__':
  main(sys.argv)
    

Enviar consultas a la API de Tag Manager

El objeto de servicio de Tag Manager se puede utilizar para enviar consultas a la API de Tag Manager. Para implementar el programa de ejemplo, sigue estos pasos:

  1. Recupera el contenedor Saludos.
  2. Crea la etiqueta de Universal Analytics.
  3. Crea la regla que activará la etiqueta.
  4. Actualiza la etiqueta para que la ejecute la regla.

1. Recuperar el contenedor Saludos

La siguiente función indica cómo se puede usar un objeto de servicio de Tag Manager para solicitar a la API de Tag Manager una lista que contenga todos los contenedores de una cuenta y recuperar el contenedor llamado Saludos.

Java

  /*
   * Find the greetings container ID.
   *
   * @param service the Tag Manager service object.
   * @param accountId the ID of the Tag Manager account from which to retrieve the
   *    Greetings container.
   *
   * @return the greetings container if it exists.
   *
   */
  private static Container findGreetingsContainer(Tagmanager service, String accountId)
      throws Exception {
    for (Container container :
        service.accounts().containers().list(accountId).execute().getContainers()) {
      if (container.getName().equals("Greetings")) {
        return container;
      }
    }
    throw new IllegalArgumentException("No container named Greetings in given account");
  }
    

Python

def FindGreetingsContainerId(service, account_id):
  """Find the greetings container ID.

  Args:
    service: the Tag Manager service object.
    account_id: the ID of the Tag Manager account from which to retrieve the
      Greetings container.

  Returns:
    The dictionary that represents the greetings container if it exists, or None
    if it does not.
  """
  # Query the Tag Manager API to list all containers for the given account.
  container_wrapper = service.accounts().containers().list(
      accountId=account_id).execute()

  # Find and return the Greetings container if it exists.
  for container in container_wrapper['containers']:
    if container['name'] == 'Greetings':
      return container['containerId']
  return None
    

A continuación, actualiza la parte de ejecución principal del programa para que llame a la función findGreetingsContainer a partir de un accountId de Tag Manager. Por ejemplo:

Java

  public static void main(String[] args) {
    try {
      httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      dataStoreFactory = new FileDataStoreFactory(DATA_STORE_DIR);

      // Authorization flow.
      Credential credential = authorize();
      Tagmanager manager = new Tagmanager.Builder(httpTransport, JSON_FACTORY, credential)
          .setApplicationName(APPLICATION_NAME).build();

      // Get tag manager account ID.
      String accountId = args[0];

      // Find the greetings container.
      Container greetings = findGreetingsContainer(manager, accountId);

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
    

Python

def main(argv):
  # Get tag manager account ID from command line.
  assert len(argv) == 2 and 'usage: gtm-api-hello-world.py <account_id>'
  account_id = str(argv[1])

  # Define the auth scopes to request.
  scope = ['https://www.googleapis.com/auth/tagmanager.edit.containers']

  # Authenticate and construct service.
  service = GetService('tagmanager', 'v1', scope, 'client_secrets.json')

  # Find the greetings container.
  container_id = FindGreetingsContainerId(service, account_id)
    

2. Crear la etiqueta de Universal Analytics

El siguiente fragmento de código usa la API de Tag Manager para crear una etiqueta de Universal Analytics. Consulta la referencia del método de creación de etiquetas si quieres ver la lista de propiedades obligatorias y opcionales que se pueden definir al crear etiquetas y la referencia del diccionario del recurso Tag si quieres ver una lista de propiedades de cada tipo de etiqueta.

Java

  /**
   * Create the Universal Analytics Hello World Tag.
   *
   * @param accountId the ID of the account holding the container.
   * @param containerId the ID of the container to create the tag in.
   * @param service the Tag Manager service object.
   * @return the newly created Tag resource.
   */
  private static Tag createHelloWorldTag(String accountId, String containerId, Tagmanager service) {
    Tag ua = new Tag();
    ua.setName("Universal Analytics Hello World");
    ua.setType("ua");

    List<Parameter> uaParams = new ArrayList<Parameter>();
    Parameter trackingId = new Parameter();
    trackingId.setKey("trackingId").setValue(UA_TRACKING_ID).setType("template");
    uaParams.add(trackingId);

    ua.setParameter(uaParams);
    ua = service.accounts().containers().tags().create(accountId, containerId, ua)
        .execute();

    return ua;
  }

    

Python

def CreateHelloWorldTag(service, account_id, container_id, tracking_id):
  """Create the Universal Analytics Hello World Tag.

  Args:
    service: the Tag Manager service object.
    account_id: the ID of the account holding the container.
    container_id: the ID of the container to create the tag in.
    tracking_id: the Universal Analytics tracking ID to use.

  Returns:
    The API response as a dict representing the newly created Tag resource
    or an error.
  """

  hello_world_tag = {
      'name': 'Universal Analytics Hello World',
      'type': 'ua',
      'parameter': [{
          'key': 'trackingId',
          'type': 'template',
          'value': str(tracking_id),
      }],
  }

  response = service.accounts().containers().tags().create(
      accountId=account_id,
      containerId=container_id,
      body=hello_world_tag).execute()

  return response

    

3. Crear la regla que activará la etiqueta.

Ahora que has creado una etiqueta, el siguiente paso es crear una regla que la ejecute en cualquier página que termine por hello-world.html.

La regla se llamará Hello World Rule y ejecutará la etiqueta cuando se cumpla una sola condición de tipo endsWith. Por ejemplo:

Java

  /**
   * Create the Hello World Rule.
   *
   * @param accountId the ID of the account holding the container.
   * @param containerId the ID of the container to create the rule in.
   * @param service the Tag Manager service object.
   *
   * @return the newly created Rule resource.
   **/
  private static Rule createHelloWorldRule(String accountId, String containerId, Tagmanager service) {
    Rule helloWorld = new Rule();
    helloWorld.setName("Hello World");

    List<Condition> conditions = new ArrayList<Condition>();
    Condition endsWithHelloWorld = new Condition();
    endsWithHelloWorld.setType("endsWith");
    List<Parameter> params = new ArrayList<Parameter>();
    params.add(new Parameter().setKey("arg0").setValue("{{url}}").setType("template"));
    params.add(new Parameter().setKey("arg1").setValue("hello-world.html").setType("template"));
    endsWithHelloWorld.setParameter(params);
    conditions.add(endsWithHelloWorld);

    helloWorld.setCondition(conditions);
    helloWorld = service.accounts().containers().rules().create(accountId, containerId, helloWorld)
        .execute();

    return helloWorld;
  }

    

Python

def CreateHelloWorldRule(service, account_id, container_id):
  """Create the Hello World Rule.

  Args:
    service: the Tag Manager service object.
    account_id: the ID of the account holding the container.
    container_id: the ID of the container to create the rule in.

  Returns:
    The API response as a dict representing the newly created Rule resource
    or an error.
  """

  hello_world_rule = {
      'name': 'Hello World Rule',
      'condition': [{
          'parameter': [
              {'key': 'arg0', 'type': 'template', 'value': '{{url}}'},
              {'key': 'arg1', 'type': 'template', 'value': 'hello-world.html'},
          ],
          'type': 'endsWith',
      }]
  }

  response = service.accounts().containers().rules().create(
      accountId=account_id,
      containerId=container_id,
      body=hello_world_rule).execute()

  return response

    

4. Actualizar la etiqueta para que la ejecute la regla.

Ahora que se han creado una etiqueta y una regla, es necesario asociarlos entre sí. Para hacerlo, añade el ruleId a la lista de firingRuleIds asociados con la etiqueta. Por ejemplo:

Java

  /**
   * Update a Tag with a Rule.
   *
   * @param tag the tag to associate with the rule.
   * @param rule the rule to associate with the tag.
   *
   */
  private static void fireTagOnRule(Tag tag, Rule rule) {
    List<String> firingRuleIds = new ArrayList<String>();
    firingRuleIds.add(rule.getRuleId());
    tag.setFiringRuleId(firingRuleIds);
  }
    

Python

def UpdateHelloWorldTagWithRule(service, account_id, container_id, tag_id,
                                rule_id):
  """Update a Tag with a Rule.

  Args:
    service: the Tag Manager service object.
    account_id:  the ID of the account holding the container.
    container_id: the ID of the container to create the rule in.
    tag_id: the ID of the tag to associate with the rule.
    rule_id: the ID of the rule to associate with the tag.
  """
  # Get the tag to update.
  tag = service.accounts().containers().tags().get(
      accountId=account_id,
      containerId=container_id,
      tagId=tag_id).execute()

  # Update the Firing Rule for the Tag.
  tag['firingRuleId'] = [rule_id]

  # Update the Tag.
  response = service.accounts().containers().tags().update(
      accountId=account_id,
      containerId=container_id,
      tagId=tag_id,
      body=tag).execute()
    

A continuación, actualiza la parte de ejecución principal del programa para llamar a las funciones de creación y actualización. Por ejemplo:

Java

  public static void main(String[] args) {
    try {
      httpTransport = GoogleNetHttpTransport.newTrustedTransport();
      dataStoreFactory = new FileDataStoreFactory(DATA_STORE_DIR);

      // Authorization flow.
      Credential credential = authorize();
      Tagmanager manager = new Tagmanager.Builder(httpTransport, JSON_FACTORY, credential)
          .setApplicationName(APPLICATION_NAME).build();

      // Get tag manager account ID.
      String accountId = args[0];

      // Find the greetings container.
      Container greetings = findGreetingsContainer(manager, accountId);
      String containerId = greetings.getContainerId();

      // Create the hello world tag.
      Tag ua = createUATag(accountId, containerId, manager);

      // Create the hello world rule.
      Rule hello = createHelloWorldRule(accountId, containerId, manager);

      // Update the hello world tag to fire based on the hello world tag.
      fireTagOnRule(ua, hello);
      ua = manager.accounts().containers().tags().update(accountId, containerId, ua.getTagId(), ua)
          .execute();

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
    

Python

def main(argv):
  # Get tag manager account ID from command line.
  assert len(argv) == 2 and 'usage: gtm-api-hello-world.py <account_id>'
  account_id = str(argv[1])

  # Define the auth scopes to request.
  scope = ['https://www.googleapis.com/auth/tagmanager.edit.containers']

  # Authenticate and construct service.
  service = GetService('tagmanager', 'v1', scope, 'client_secrets.json')

  # Find the greetings container.
  container_id = FindGreetingsContainerId(service, account_id)

  # Create the hello world tag.
  tag = CreateHelloWorldTag(service, account_id, container_id, 'UA-1234-5')

  # Create the hello world rule.
  rule = CreateHelloWorldRule(service, account_id, container_id)

  # Update the hello world tag to fire based on the hello world tag.
  UpdateHelloWorldTagWithRule(service, account_id, container_id, tag['tagId'], rule['ruleId'])
    

Pasos siguientes

Ahora que ya sabes cómo funciona la API, puedes consultar estos recursos adicionales: