Este guia do desenvolvedor apresenta as etapas necessárias para acessar, criar e gerenciar entidades em uma conta do Gerenciador de tags do Google usando a API Tag Manager v2.
Introdução
Este guia explica as várias etapas necessárias para acessar e configurar uma conta do Gerenciador de tags do Google. Após a conclusão, você terá uma compreensão básica de como:
- criar um objeto de serviço do Gerenciador de tags;
- autenticar e autorizar um usuário;
- trabalhar com a API Tag Manager para acessar e gerenciar recursos.
Antes de começar
Antes de começar a usar o guia, recomendamos que você acesse a Central de Ajuda do Gerenciador de tags do Google para se familiarizar com o produto.
Usar uma conta de teste
Se você pretende usar a API Tag Manager para criar, configurar ou excluir entidades, é recomendável implementar e verificar seu código com uma conta de teste. O uso de uma conta de teste ajudará a evitar que você faça alterações acidentais em uma conta ativa. Depois que você testar e confirmar que seu código está funcionando conforme o esperado usando a conta de teste, poderá começar a usar a implementação com suas contas reais.
Selecionar uma linguagem
Selecione a linguagem de programação que você pretende usar, por exemplo:
Python
O Python foi utilizado em todos os snippets de código neste guia.
JavaScript
O Javascript foi utilizado em todos os snippets de código neste guia.
Visão geral do programa
O programa de exemplo incluído neste guia é um aplicativo de linha de comando. Com um ID de conta, o app encontra um contêiner chamado Greetings e cria uma tag do Universal Analytics nesse contêiner. Quando um usuário visita hello-world.html, a tag envia um hit de exibição de página.
Para desenvolver esse aplicativo, siga estas etapas:
- Configure seu ambiente de desenvolvimento e projeto no Console de APIs do Google.
- Crie um objeto de serviço do Gerenciador de tags.
- Autorize o acesso a uma conta do Gerenciador de tags.
- Crie um objeto de serviço do Gerenciador de tags.
- Consulte a API, processe a resposta e gere os resultados.
- Use um objeto de serviço inicializado do Gerenciador de tags.
- Use o objeto de serviço do Gerenciador de tags para consultar a API Tag Manager e fazer as seguintes tarefas:
- Recuperar o contêiner Greetings da conta autenticada do Gerenciador de tags do Google.
- Criar um novo espaço de trabalho.
- Criar a tag do Universal Analytics.
- Criar o acionador para disparar a tag.
- Atualizar a tag para disparar com o acionador.
Configurar o ambiente de desenvolvimento e o projeto
Criar o contêiner Greetings
Este guia considera que você tem uma conta do Gerenciador de tags do Google com um contêiner chamado Greetings. Siga as instruções de Configuração e fluxo de trabalho (Web) para criar uma conta e um contêiner chamado Greetings.
Instalar uma biblioteca de cliente
Antes de começar, instale e configure uma Biblioteca de cliente de APIs do Google.
Criar e configurar um projeto no Console de APIs do Google
Para começar a usar a API Tag Manager, primeiro use a ferramenta de configuração que oferece orientações para criar um projeto no console de APIs do Google, ativar a API e criar credenciais.
Este guia usa um fluxo de autenticação de aplicativo instalado. Siga as instruções abaixo para criar suas credenciais de projeto. Quando solicitado, selecione Installed Application para APPLICATION TYPE e Other para INSTALLED APPLICATION TYPE.
- Na página "Credenciais", clique em Criar credenciais > ID do cliente OAuth para criar suas credenciais do OAuth 2.0 ou Criar credenciais > Chave da conta de serviço para criar uma conta de serviço.
- Se você criou um ID do cliente OAuth, então selecione seu tipo de aplicativo.
- Preencha o formulário e clique em Criar.
Os IDs do cliente e as chaves da conta de serviço do aplicativo agora serão exibidas na página "Credenciais". Para saber mais, clique em um ID do cliente. Os parâmetros variam dependendo do tipo de ID, mas podem incluir endereço de e-mail, chave secreta do cliente, origens de JavaScript ou URIs de redirecionamento.
Clique no botão Fazer o download do JSON para fazer o download dos detalhes do cliente. Renomeie este arquivo como client_secrets.json. Ele será usado mais tarde para fins de autenticação.
Crie um objeto de serviço do Gerenciador de tags
Você usará o objeto service do Gerenciador de tags para fazer solicitações de API.
Veja as etapas necessárias para criar um objeto de serviço do Gerenciador de tags:
- Autorizar o acesso a uma conta do Gerenciador de tags do Google
- Instanciar o objeto de serviço do Gerenciador de tags.
Autorize o acesso a uma conta do Gerenciador de tags do Google
Quando um usuário inicia um aplicativo desenvolvido com a API Google Tag Manager, ele precisa conceder ao aplicativo acesso à conta do Gerenciador de tags do Google. Esse processo é denominado autorização. O método recomendado para a autorização de usuários é o OAuth 2.0. Caso queira saber mais, leia Autorização da API Tag Manager.
O código abaixo usa os detalhes do projeto e do cliente criados acima para autenticar o usuário do aplicativo e pede permissão para acessar o Gerenciador de tags do Google em nome dele.
O aplicativo tentará abrir o navegador padrão e levar o usuário até um URL hospedado em google.com. O usuário precisará fazer login e conceder ao app acesso à conta do Gerenciador de tags dele. Após ser concedido, o aplicativo tentará ler um código da janela do navegador e fechará a janela.
Observação: se ocorrer um erro, o aplicativo solicitará que o usuário informe o código de autorização na linha de comando.
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', 'v2', scope, 'client_secrets.json')
if __name__ == '__main__':
main(sys.argv)
JavaScript
<html>
<head>
<script type="text/javascript">
// Your Client ID can be retrieved from your project in the Google
// Developer Console, https://console.developers.google.com
var CLIENT_ID = TODO;
var SCOPES = [
'https://www.googleapis.com/auth/tagmanager.manage.accounts',
'https://www.googleapis.com/auth/tagmanager.edit.containers',
'https://www.googleapis.com/auth/tagmanager.delete.containers',
'https://www.googleapis.com/auth/tagmanager.edit.containerversions',
'https://www.googleapis.com/auth/tagmanager.manage.users',
'https://www.googleapis.com/auth/tagmanager.publish'
];
// Parameter values used by the script
ACCOUNT_PATH = TODO; // such as: 'accounts/555555';
CONTAINER_NAME = 'Greetings';
WORKSPACE_NAME = 'Example workspace';
/**
* Check if current user has authorization for this application.
*
* @param {bool} immediate Whether login should use the "immediate mode", which
* causes the security token to be refreshed behind the scenes with no UI.
*/
function checkAuth(immediate) {
var authorizeCheckPromise = new Promise((resolve) => {
gapi.auth.authorize(
{ client_id: CLIENT_ID, scope: SCOPES.join(' '), immediate: immediate },
resolve);
});
authorizeCheckPromise
.then(handleAuthResult)
.then(loadTagManagerApi)
.then(runTagManagerExample)
.catch(() => {
console.log('You must authorize any access to the api.');
});
}
/**
* Check if current user has authorization for this application.
*/
function checkAuth() {
checkAuth(true);
}
/**
* Initiate auth flow in response to user clicking authorize button.
*
* @param {Event} event Button click event.
* @return {boolean} Returns false.
*/
function handleAuthClick(event) {
checkAuth();
return false;
}
/**
* Handle response from authorization server.
*
* @param {Object} authResult Authorization result.
* @return {Promise} A promise to call resolve if authorize or redirect to a
* login flow.
*/
function handleAuthResult(authResult) {
return new Promise((resolve, reject) => {
var authorizeDiv = document.getElementById('authorize-div');
if (authResult && !authResult.error) {
// Hide auth UI, then load client library.
authorizeDiv.style.display = 'none';
resolve();
} else {
// Show auth UI, allowing the user to initiate authorization by
// clicking authorize button.
authorizeDiv.style.display = 'inline';
reject();
}
});
}
/**
* Load Tag Manager API client library.
*
* @return {Promise} A promise the load the Tag Manager API library.
*/
function loadTagManagerApi() {
return new Promise((resolve, reject) => {
console.log('Load Tag Manager api');
gapi.client.load('tagmanager', 'v2', resolve);
});
}
/**
* Interacts with the tagmanager api v2 to create a container, workspace,
* trigger, and tag.
*
* @return {Promise} A promise to run the Tag Manager example.
*/
function runTagManagerExample() {
return new Promise((resolve, reject) => {
console.log('Running Tag Manager Example.');
resolve();
});
}
/**
* Logs an error message to the console.
*
* @param {string|Object} error The error to log to the console.
*/
function handleError(error) {
console.log('Error when interacting with GTM API');
console.log(error);
}
/**
* Wraps an API request into a promise.
*
* @param {Object} a request to the API.
* @return {Promise} A promise to execute the API request.
*/
function requestPromise(request) {
return new Promise((resolve, reject) => {
request.execute((response) => {
if (response.code) {
reject(response);
}
resolve(response);
});
});
}
</script>
<script src="https://apis.google.com/js/client.js?onload=checkAuth">
</script>
</head>
<body>
<div id="authorize-div" style="display: none">
<span>Authorize access to Tag Manager API</span>
<!--Button for the user to click to initiate auth sequence -->
<button id="authorize-button" onclick="handleAuthClick(event)">
Authorize
</button>
</div>
<pre id="output"></pre>
</body>
</html>
Consultar a API Tag Manager
O objeto de serviço do Gerenciador de tags pode ser usado para consultar a API Tag Manager. Para implementar o programa de amostra, siga estas etapas:
- Recuperar o contêiner "Greetings".
- Criar a tag do Universal Analytics.
- Criar o acionador para disparar a tag.
- Atualizar a tag para disparar com o acionador.
1. Recuperar o contêiner Greetings
A função a seguir mostra como um objeto de serviço do Gerenciador de tags pode ser utilizado para consultar a API Tag Manager e listar todos os contêineres de uma conta, e recuperar o contêiner nomeado Greetings.
Python
def FindGreetingsContainer(service, account_path):
"""Find the greetings container.
Args:
service: the Tag Manager service object.
account_path: the path of the Tag Manager account from which to retrieve the
Greetings container.
Returns:
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(
parent=account_path).execute()
# Find and return the Greetings container if it exists.
for container in container_wrapper['container']:
if container['name'] == 'Greetings':
return container
return None
JavaScript
/**
* Returns the greetings container if it exists.
*
* @param {string} accountPath The account which contains the Greetings
* container.
* @return {Promise} A promise to find the greetings container.
*/
function findContainer(accountPath, containerName) {
console.log('Finding container in account:' + accountPath);
var request = gapi.client.tagmanager.accounts.containers.list({
'parent': accountPath
});
return requestPromise(request)
.then((response) => {
var containers = response.container || [];
var container =
containers.find((container) => container.name === containerName);
return container ||
Promise.reject('Unable to find ' + containerName +' container.');
});
}
Em seguida, atualize a principal ramificação de execução do programa para chamar a função findGreetingsContainer conforme o accountId do Gerenciador de tags. Exemplo:
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])
account_path = 'accounts/%s' % account_id
# Define the auth scopes to request.
scope = ['https://www.googleapis.com/auth/tagmanager.edit.containers']
# Authenticate and construct service.
service = GetService('tagmanager', 'v2', scope, 'client_secrets.json')
# Find the greetings container.
container = FindGreetingsContainer(service, account_path)
if __name__ == '__main__':
main(sys.argv)
JavaScript
/**
* Interacts with the tagmanager api v2 to create a container, workspace,
* trigger, and tag.
*
* @return {Promise} A promise to run the tag manager example.
*/
function runTagManagerExample() {
return new Promise((resolve, reject) => {
console.log('Running Tag Manager Example.');
var trigger = null;
var workspace = null;
findContainer(ACCOUNT_PATH, CONTAINER_NAME)
.catch(handleError);
resolve();
});
}
2. Criar um novo espaço de trabalho
O snippet de código a seguir usa a API Tag Manager para criar um novo espaço de trabalho, que usamos para gerenciar nossas alterações em acionadores e tags. Consulte a referência do método "create" para espaço de trabalho para ver a lista de propriedades exigidas e opcionais que podem ser definidas ao criar um espaço de trabalho.
Python
def CreateWorkspace(service, container):
"""Creates a workspace named 'my workspace'.
Args:
service: the Tag Manager service object.
container: the container to insert the workspace within.
Returns:
The created workspace.
"""
return service.accounts().containers().workspaces().create(
parent=container['path'],
body={
'name': 'my workspace',
}).execute()
JavaScript
/**
* Creates a workspace in the Greetings container.
*
* @param {Object} container The container to create a new workspace.
* @return {Promise} A promise to create a workspace.
*/
function createWorkspace(container) {
console.log('Creating workspace in container:' + container.path);
var request = gapi.client.tagmanager.accounts.containers.workspaces.create(
{ 'parent': container.path },
{ name: WORKSPACE_NAME, description: 'my workspace created via api' });
return requestPromise(request);
}
3. Criar a tag do Universal Analytics
O snippet de código a seguir usa a API Tag Manager para criar uma tag do Universal Analytics. Consulte a referência do método "create" para tag e veja a lista de propriedades obrigatórias e opcionais que podem ser definidas ao criar uma tag. Para ver uma lista de propriedades de cada tipo de tag, confira a referência do dicionário de tags.
Python
def CreateHelloWorldTag(service, workspace, tracking_id):
"""Create the Universal Analytics Hello World Tag.
Args:
service: the Tag Manager service object.
workspace: the workspace to create a tag within.
tracking_id: the Universal Analytics tracking ID to use.
Returns:
The created tag.
"""
hello_world_tag = {
'name': 'Universal Analytics Hello World',
'type': 'ua',
'parameter': [{
'key': 'trackingId',
'type': 'template',
'value': str(tracking_id),
}],
}
return service.accounts().containers().workspaces().tags().create(
parent=workspace['path'],
body=hello_world_tag).execute()
JavaScript
/**
* Creates a universal analytics tag.
*
* @param {Object} workspace The workspace to create the tag
* @return {Promise} A promise to create a hello world tag.
*/
function createHelloWorldTag(workspace) {
console.log('Creating hello world tag');
var helloWorldTag = {
'name': 'Universal Analytics Hello World',
'type': 'ua',
'parameter':
[{ 'key': 'trackingId', 'type': 'template', 'value': 'UA-1234-5' }],
};
var request =
gapi.client.tagmanager.accounts.containers.workspaces.tags.create(
{ 'parent': workspace.path }, helloWorldTag);
return requestPromise(request);
}
4. Criar o acionador para disparar a tag
Agora que uma tag foi criada, a próxima etapa é criar um acionador que será disparado em qualquer página.
Ele se chamará Hello World Trigger e será disparado em qualquer visualização de página. Exemplo:
Python
def CreateHelloWorldTrigger(service, workspace):
"""Create the Hello World Trigger.
Args:
service: the Tag Manager service object.
workspace: the workspace to create the trigger within.
Returns:
The created trigger.
"""
hello_world_trigger = {
'name': 'Hello World Rule',
'type': 'PAGEVIEW'
}
return service.accounts().containers().workspaces().triggers().create(
parent=workspace['path'],
body=hello_world_trigger).execute()
JavaScript
/**
* Creates a page view trigger.
*
* @param {Object} workspace The workspace to create the trigger in.
* @return {Promise} A promise to create a page view trigger.
*/
function createHelloWorldTrigger(workspace) {
console.log('Creating hello world trigger in workspace');
var helloWorldTrigger = { 'name': 'Hello World Trigger', 'type': 'PAGEVIEW' };
var request =
gapi.client.tagmanager.accounts.containers.workspaces.triggers.create(
{ 'parent': workspace.path }, helloWorldTrigger);
return requestPromise(request);
}
5. Atualizar a tag para disparar com o acionador
Agora que uma tag e um acionador foram criados, eles precisam ser vinculados. Para fazer isso, adicione triggerId à lista de firingTriggerIds associada à tag. Exemplo:
Python
def UpdateHelloWorldTagWithTrigger(service, tag, trigger):
"""Update a Tag with a Trigger.
Args:
service: the Tag Manager service object.
tag: the tag to associate with the trigger.
trigger: the trigger to associate with the tag.
"""
# Get the tag to update.
tag = service.accounts().containers().workspaces().tags().get(
path=tag['path']).execute()
# Update the Firing Trigger for the Tag.
tag['firingTriggerId'] = [trigger['triggerId']]
# Update the Tag.
response = service.accounts().containers().workspaces().tags().update(
path=tag['path'],
body=tag).execute()
JavaScript
/**
* Updates a tag to fire on a particular trigger.
*
* @param {Object} tag The tag to update.
* @param {Object} trigger The trigger which causes the tag to fire.
* @return {Promise} A promise to update a tag to fire on a particular trigger.
*/
function updateHelloWorldTagWithTrigger(tag, trigger) {
console.log('Update hello world tag with trigger');
tag['firingTriggerId'] = [trigger.triggerId];
var request =
gapi.client.tagmanager.accounts.containers.workspaces.tags.update(
{ 'path': tag.path }, tag);
return requestPromise(request);
}
Em seguida, atualize o principal branch de execução do programa para chamar a função de criação de atualização. Exemplo:
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])
account_path = 'accounts/%s' % account_id
# Define the auth scopes to request.
scope = ['https://www.googleapis.com/auth/tagmanager.edit.containers']
# Authenticate and construct service.
service = GetService('tagmanager', 'v2', scope, 'client_secrets.json')
# Find the greetings container.
container = FindGreetingsContainer(service, account_path)
# Create a new workspace.
workspace = CreateWorkspace(service, container)
# Create the hello world tag.
tag = CreateHelloWorldTag(
service, workspace, 'UA-1234-5')
# Create the hello world Trigger.
trigger = CreateHelloWorldTrigger(
service, workspace)
# Update the hello world tag to fire based on the hello world tag.
UpdateHelloWorldTagWithTrigger(service, tag, trigger)
if __name__ == '__main__':
main(sys.argv)
JavaScript
/**
* Interacts with the tagmanager api v2 to create a container, workspace,
* trigger, and tag.
*
* @return {Promise} A promise to run the tag manager example.
*/
function runTagManagerExample() {
return new Promise((resolve, reject) => {
console.log('Running Tag Manager Example.');
var trigger = null;
var workspace = null;
findContainer(ACCOUNT_PATH, CONTAINER_NAME)
.then(createWorkspace)
.then((createdWorkspace) => {
workspace = createdWorkspace;
return createHelloWorldTrigger(workspace);
})
.then((createdTrigger) => {
trigger = createdTrigger;
return createHelloWorldTag(workspace);
})
.then((createdTag) => {
return updateHelloWorldTagWithTrigger(createdTag, trigger);
})
.catch(handleError);
resolve();
});
}
Exemplo completo
Expanda esta seção para ver o exemplo de código completo de todas as etapas no guia.
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 FindGreetingsContainer(service, account_path):
"""Find the greetings container.
Args:
service: the Tag Manager service object.
account_path: the path of the Tag Manager account from which to retrieve the
Greetings container.
Returns:
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(
parent=account_path).execute()
# Find and return the Greetings container if it exists.
for container in container_wrapper['container']:
if container['name'] == 'Greetings':
return container
return None
def CreateWorkspace(service, container):
"""Creates a workspace named 'my workspace'.
Args:
service: the Tag Manager service object.
container: the container to insert the workspace within.
Returns:
The created workspace.
"""
return service.accounts().containers().workspaces().create(
parent=container['path'],
body={
'name': 'my workspace',
}).execute()
def CreateHelloWorldTag(service, workspace, tracking_id):
"""Create the Universal Analytics Hello World Tag.
Args:
service: the Tag Manager service object.
workspace: the workspace to create a tag within.
tracking_id: the Universal Analytics tracking ID to use.
Returns:
The created tag.
"""
hello_world_tag = {
'name': 'Universal Analytics Hello World',
'type': 'ua',
'parameter': [{
'key': 'trackingId',
'type': 'template',
'value': str(tracking_id),
}],
}
return service.accounts().containers().workspaces().tags().create(
parent=workspace['path'],
body=hello_world_tag).execute()
def CreateHelloWorldTrigger(service, workspace):
"""Create the Hello World Trigger.
Args:
service: the Tag Manager service object.
workspace: the workspace to create the trigger within.
Returns:
The created trigger.
"""
hello_world_trigger = {
'name': 'Hello World Rule',
'type': 'PAGEVIEW'
}
return service.accounts().containers().workspaces().triggers().create(
parent=workspace['path'],
body=hello_world_trigger).execute()
def UpdateHelloWorldTagWithTrigger(service, tag, trigger):
"""Update a Tag with a Trigger.
Args:
service: the Tag Manager service object.
tag: the tag to associate with the trigger.
trigger: the trigger to associate with the tag.
"""
# Get the tag to update.
tag = service.accounts().containers().workspaces().tags().get(
path=tag['path']).execute()
# Update the Firing Trigger for the Tag.
tag['firingTriggerId'] = [trigger['triggerId']]
# Update the Tag.
response = service.accounts().containers().workspaces().tags().update(
path=tag['path'],
body=tag).execute()
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])
account_path = 'accounts/%s' % account_id
# Define the auth scopes to request.
scope = ['https://www.googleapis.com/auth/tagmanager.edit.containers']
# Authenticate and construct service.
service = GetService('tagmanager', 'v2', scope, 'client_secrets.json')
# Find the greetings container.
container = FindGreetingsContainer(service, account_path)
# Create a new workspace.
workspace = CreateWorkspace(service, container)
# Create the hello world tag.
tag = CreateHelloWorldTag(
service, workspace, 'UA-1234-5')
# Create the hello world Trigger.
trigger = CreateHelloWorldTrigger(
service, workspace)
# Update the hello world tag to fire based on the hello world tag.
UpdateHelloWorldTagWithTrigger(service, tag, trigger)
if __name__ == '__main__':
main(sys.argv)
JavaScript
<html>
<head>
<script type="text/javascript">
// Your Client ID can be retrieved from your project in the Google
// Developer Console, https://console.developers.google.com
var CLIENT_ID = TODO;
var SCOPES = [
'https://www.googleapis.com/auth/tagmanager.manage.accounts',
'https://www.googleapis.com/auth/tagmanager.edit.containers',
'https://www.googleapis.com/auth/tagmanager.delete.containers',
'https://www.googleapis.com/auth/tagmanager.edit.containerversions',
'https://www.googleapis.com/auth/tagmanager.manage.users',
'https://www.googleapis.com/auth/tagmanager.publish'
];
// Parameter values used by the script
ACCOUNT_PATH = TODO; // such as: 'accounts/555555';
CONTAINER_NAME = 'Greetings';
WORKSPACE_NAME = 'Example workspace';
/**
* Check if current user has authorization for this application.
*
* @param {bool} immediate Whether login should use the "immediate mode",
* which causes the security token to be refreshed behind the scenes
* with no UI.
*/
function checkAuth(immediate) {
var authorizeCheckPromise = new Promise((resolve) => {
gapi.auth.authorize(
{ client_id: CLIENT_ID, scope: SCOPES.join(' '), immediate: immediate },
resolve);
});
authorizeCheckPromise
.then(handleAuthResult)
.then(loadTagManagerApi)
.then(runTagManagerExample)
.catch(() => {
console.log('You must authorize any access to the api.');
});
}
/**
* Check if current user has authorization for this application.
*/
function checkAuth() {
checkAuth(true);
}
/**
* Initiate auth flow in response to user clicking authorize button.
*
* @param {Event} event Button click event.
* @return {boolean} Returns false.
*/
function handleAuthClick(event) {
checkAuth();
return false;
}
/**
* Handle response from authorization server.
*
* @param {Object} authResult Authorization result.
* @return {Promise} A promise to call resolve if authorize or redirect to a
* login flow.
*/
function handleAuthResult(authResult) {
return new Promise((resolve, reject) => {
var authorizeDiv = document.getElementById('authorize-div');
if (authResult && !authResult.error) {
// Hide auth UI, then load client library.
authorizeDiv.style.display = 'none';
resolve();
} else {
// Show auth UI, allowing the user to initiate authorization by
// clicking authorize button.
authorizeDiv.style.display = 'inline';
reject();
}
});
}
/**
* Load Tag Manager API client library.
* @return {Promise} A promise to load the tag manager api library.
*/
function loadTagManagerApi() {
return new Promise((resolve, reject) => {
console.log('Load Tag Manager api');
gapi.client.load('tagmanager', 'v2', resolve);
});
}
/**
* Interacts with the tagmanager api v2 to create a container,
* workspace, trigger, and tag.
*
* @return {Promise} A promise to run the tag manager example.
*/
function runTagManagerExample() {
return new Promise((resolve, reject) => {
console.log('Running Tag Manager Example.');
var trigger = null;
var workspace = null;
findContainer(ACCOUNT_PATH, CONTAINER_NAME)
.then(createWorkspace)
.then((createdWorkspace) => {
workspace = createdWorkspace;
return createHelloWorldTrigger(workspace);
})
.then((createdTrigger) => {
trigger = createdTrigger;
return createHelloWorldTag(workspace);
})
.then((createdTag) => {
return updateHelloWorldTagWithTrigger(createdTag, trigger);
})
.catch(handleError);
resolve();
});
}
/**
* Returns the greetings container if it exists.
*
* @param {string} accountPath The account which contains the Greetings
* container.
* @param {string} containerName The name of the container to find.
* @return {Promise} A promise to find the greetings container.
*/
function findContainer(accountPath, containerName) {
console.log('Finding container in account:' + accountPath);
var request = gapi.client.tagmanager.accounts.containers.list({
'parent': accountPath
});
return requestPromise(request)
.then((response) => {
var containers = response.container || [];
var container = containers.find(
(container) => container.name === containerName);
return container || Promise.reject(
'Unable to find ' + containerName +' container.');
});
}
/**
* Creates a workspace in the Greetings container.
*
* @param {Object} container The container to create a new workspace.
* @return {Promise} A promise to create a workspace.
*/
function createWorkspace(container) {
console.log('Creating workspace in container:' + container.path);
var request = gapi.client.tagmanager.accounts.containers.workspaces.create(
{ 'parent': container.path },
{ name: WORKSPACE_NAME, description: 'my workspace created via api' });
return requestPromise(request);
}
/**
* Creates a page view trigger.
*
* @param {Object} workspace The workspace to create the trigger in.
* @return {Promise} A promise to create a page view trigger.
*/
function createHelloWorldTrigger(workspace) {
console.log('Creating hello world trigger in workspace');
var helloWorldTrigger =
{ 'name': 'Hello World Trigger', 'type': 'PAGEVIEW' };
var request =
gapi.client.tagmanager.accounts.containers.workspaces.triggers.create(
{ 'parent': workspace.path }, helloWorldTrigger);
return requestPromise(request);
}
/**
* Creates a universal analytics tag.
*
* @param {Object} workspace The workspace to create the tag
* @return {Promise} A promise to create a hello world tag.
*/
function createHelloWorldTag(workspace) {
console.log('Creating hello world tag');
var helloWorldTag = {
'name': 'Universal Analytics Hello World',
'type': 'ua',
'parameter':
[{ 'key': 'trackingId', 'type': 'template', 'value': 'UA-1234-5' }],
};
var request =
gapi.client.tagmanager.accounts.containers.workspaces.tags.create(
{ 'parent': workspace.path }, helloWorldTag);
return requestPromise(request);
}
/**
* Updates a tag to fire on a particular trigger.
*
* @param {Object} tag The tag to update.
* @param {Object} trigger The trigger which causes the tag to fire.
* @return {Promise} A promise to update a tag to fire on a particular
* trigger.
*/
function updateHelloWorldTagWithTrigger(tag, trigger) {
console.log('Update hello world tag with trigger');
tag['firingTriggerId'] = [trigger.triggerId];
var request =
gapi.client.tagmanager.accounts.containers.workspaces.tags.update(
{ 'path': tag.path }, tag);
return requestPromise(request);
}
/**
* Logs an error message to the console.
*
* @param {string|Object} error The error to log to the console.
*/
function handleError(error) {
console.log('Error when interacting with GTM API');
console.log(error);
}
/**
* Wraps an API request into a promise.
*
* @param {Object} request the API request.
* @return {Promise} A promise to execute the api request.
*/
function requestPromise(request) {
return new Promise((resolve, reject) => {
request.execute((response) => {
if (response.code) {
reject(response);
}
resolve(response);
});
});
}
</script>
<script src="https://apis.google.com/js/client.js?onload=checkAuth">
</script>
</head>
<body>
<div id="authorize-div" style="display: none">
<span>Authorize access to Tag Manager API</span>
<!--Button for the user to click to initiate auth sequence -->
<button id="authorize-button" onclick="handleAuthClick(event)">
Authorize
</button>
</div>
<pre id="output"></pre>
</body>
</html>
A seguir
Agora que você conhece o funcionamento da API, veja estes outros recursos:
- Referência de API: aprenda sobre a interface da API e as operações compatíveis.
- Referência de parâmetro: aprenda sobre os parâmetros de configuração para tags e variáveis.
- Veja uma lista de tags compatíveis na Referência do dicionário de tags.
- Veja a lista de variáveis que podem ser configuradas na Referência do dicionário de variáveis.