Rastreie vídeos com o Google Analytics 4 e o Google Tag Manager
Embora o Google Analytics 4 ofereça alguns recursos integrados de rastreamento de vídeo, ainda pode haver alguns casos em que você precisará fazer configurações adicionais no Gerenciador de tags do Google. E eu queria cobrir diferentes situações, desde as mais simples até as mais complexas.
Na postagem do blog de hoje, mostrarei como rastrear vídeos com o Google Analytics 4 e o Gerenciador de tags do Google. Vamos começar com a Medição aprimorada, depois ir para a configuração personalizada, depois para players de vídeo que não sejam do YouTube e muito mais.
Então qual é o plano?
- Primeiro, daremos uma olhada rápida no rastreamento de vídeo integrado do GA4
- Em seguida, veremos a configuração do GTM que usa o gatilho de vídeo do Youtube
- Em seguida, daremos uma olhada em um player de vídeo diferente (Vimeo)
- Em seguida, mostrarei como rastrear players de vídeo HTML5 genéricos
- Depois disso, compartilharei 3 receitas GTM (modelos de contêiner) para o rastreamento do player de vídeo mencionado acima
- Por fim, compartilharei recursos/dicas adicionais relacionados ao rastreamento de vídeo no Google Analytics 4 e GTM
Temos muito a cobrir, então vamos nos aprofundar.
#1. Rastreamento de vídeo integrado no GA4 (medição aprimorada)
Quando você cria uma nova propriedade do GA4, ela automaticamente ativa a avaliação otimizada . Este é um conjunto de recursos que rastreia eventos automaticamente e os envia para o Google Analytics 4. Entre coisas como rolagem ou rastreamento de pesquisa no site, ele também pode rastrear players de vídeo do YouTube incorporados.
Você pode verificar se habilitou isso acessando Administrador do GA4 > Fluxos de dados (de sua propriedade específica) > Clique no ícone de engrenagem .
Lá você verá se o rastreamento de vídeo está ativado. Se for, você poderá rastrear os seguintes eventos:
- video_start . Enviado quando um visitante começa a assistir a um vídeo.
- video_progress . Quando um espectador atinge um limite específico do vídeo (10%, 25%, 50%, 75%).
- vídeo_completo . Quando um visitante chega ao final do vídeo.
Juntamente com esses eventos, vários parâmetros também são rastreados:
- video_current_time . O carimbo de data/hora atual do vídeo em que o visualizador está (em segundos)
- duração_do_vídeo . Duração do vídeo em segundos.
- video_percent . O limite do vídeo (sem o sinal %)
- video_provider . O valor deste parâmetro é sempre “youtube”.
- Título do vídeo. O título do vídeo.
- video_url . Este é o URL do vídeo.
- visível . Retorna “1” se o player estiver visível na tela enquanto o engajamento do vídeo foi rastreado.
O rastreamento de vídeo na medição aprimorada funciona para vídeos incorporados do YouTube com a API JavaScript habilitada. Isso pode ser feito adicionando o atributo enablejsapi=”true” ao iframe, por exemplo:
<iframe src="https://www.youtube.com/embed/QfUSKYJz5QE" width="560" height="315" title="YouTube video player" enablejsapi="true" frameborder="0" allow="accelerometer ; gravação na área de transferência; mídia criptografada; imagem na imagem" allowfullscreen></iframe>
Ou decorando o src do iframe com “enablejsapi=1”, por exemplo:
<iframe width="560" height="315" src="https://www.youtube.com/embed/QfUSKYJz5QE?enablejsapi=1" title="YouTube video player" frameborder="0" allow="accelerometer; gravação na área de transferência; mídia criptografada; imagem na imagem" allowfullscreen></iframe>
No entanto, notei várias situações em que esse rastreamento integrado simplesmente não consegue perceber o player de vídeo do Youtube incorporado e rastrear o respectivo engajamento.
Portanto, se você estiver lidando com uma situação semelhante, leia o próximo capítulo + combine esse conhecimento com este guia de solução de problemas . Agora vou mostrar a você como utilizar os recursos integrados do GTM para rastrear vídeos do Youtube .
#2. Rastreamento de vídeo do Youtube com gatilho GTM e GA4
Se você optar por implementar o rastreamento de vídeo dessa maneira, desative os recursos de rastreamento de engajamento de vídeo na medição aprimorada. Caso contrário, você estará em maior risco de dados duplicados ocasionais (quando a medição aprimorada estiver rastreando as mesmas coisas que sua configuração GTM).
Acesse Administrador do GA4 > Fluxos de dados > Ícone de engrenagem > desativar rastreamento de engajamento de vídeo . Depois de fazer isso, vamos continuar com a configuração.
Além disso, nesta postagem do blog, presumo que você já tenha instalado o GA4 em seu contêiner GTM . Isso significa que você já criou a tag de configuração do GA4.
#2.1. Crie um gatilho de vídeo do Youtube
Tudo começa com um gatilho. No Google Tag Manager, vá para Triggers > New > Trigger Configuration e escolha Youtube Video . Em seguida, insira as seguintes configurações:
Você pode alterar o limite de porcentagem para o que quiser, basta separá-los com uma vírgula. Além disso, você pode ativar o rastreamento de pausa, busca e armazenamento em buffer. Pessoalmente, prefiro rastrear Início, Conclusão e Progresso (por exemplo, 25% do vídeo foi assistido) .
Além disso, embora Adicionar suporte à API JavaScript para todos os vídeos do YouTube seja uma configuração avançada, eu a habilito por padrão porque aumenta a chance de o rastreamento de vídeo do YouTube funcionar.
#2.2. Ativar variáveis de vídeo incorporadas
No Gerenciador de tags do Google, vá para Variáveis > Configurar e habilite todas as variáveis relacionadas ao vídeo.
#2.3. Criar uma etiqueta do Google Analytics 4
Agora, é hora de enviar os dados do vídeo do Youtube para o Google Analytics. No GTM, vá para Tags > Novo > GA4 Event Tag e insira as seguintes configurações.
Algumas partes podem ser confusas, então deixe-me explicar:
- Você pode inserir o que quiser no campo Nome do evento. Eu estava apenas tentando seguir a mesma convenção de nomenclatura usada pela Medida Aprimorada . Na minha configuração, haverá 3 nomes de eventos possíveis: video_start , video_progress e video_complete . Isso é possível por causa da variável interna chamada “Status do vídeo”.
- Todos os parâmetros de evento que incluí também são opcionais. Se você acha que alguns deles não são valiosos, vá em frente e remova-os. Eu (mais uma vez) decidi seguir a convenção de nomenclatura de Medição Aprimorada.
Na seção de acionamento, seleciono o acionador de vídeo do Youtube criado anteriormente.
#2.4 Teste a configuração
Depois de concluir todas as etapas anteriores, é hora de testar. Habilite/ atualize o modo de visualização e depuração , atualize a página em seu site com o player de vídeo do Youtube incorporado e tente interagir com ele.
Em primeiro lugar, você deve começar a ver os eventos de vídeo do Youtube no modo de visualização. Se você não os vir, leia este guia de solução de problemas .
Clique em um deles e verifique se sua tag do Google Analytics foi disparada.
Em caso afirmativo, vá para o Google Analytics 4 DebugView para verificar se você vê os eventos recebidos.
Depois de um tempo, seus dados de eventos também aparecerão nos relatórios padrão do Google Analytics e no Analysis Hub. Mas isso pode levar até 24 horas . Então seja paciente.
Além disso, não se esqueça de registrar os parâmetros como video_percent ou video_title como dimensões personalizadas (se quiser usá-los em seus relatórios do GA4).
Se o gatilho de vídeo do Youtube não estiver funcionando, leia este guia .
#3. Como rastrear o Vimeo com Google Analytics 4 e GTM
E se o seu site não contiver vídeos do Youtube incorporados? E se você estiver usando outra coisa? Nesse caso, o rastreamento de vídeo integrado do Youtube no Gerenciador de tags do Google não funcionará. Você precisa encontrar uma solução alternativa.
Tudo começa com a identificação do player de vídeo
Antes de começar com o rastreamento real das interações do player de vídeo, primeiro você precisa identificar que tipo de player de vídeo é esse. Os players de vídeo mostram claramente seu logotipo na caixa do player (por exemplo, Vimeo), outros provavelmente não serão tão óbvios.
Se o seu caso for o último, faça as seguintes etapas. No seu navegador, abra as ferramentas do desenvolvedor (no Chrome, é F12 (no Windows)) e vá para a guia Elementos . Então clique neste botão…
… e depois clique no próprio player. Agora tente navegar um pouco e localizar algumas pistas mencionando o nome do provedor do jogador. Por exemplo, neste caso, o player que estou inspecionando é o JW player.
Se você não conseguir encontrar o nome, provavelmente é um player de vídeo HTML5 .
Depois de identificar o nome do player de vídeo, basta pesquisar no Google [nome do player de vídeo] com o Gerenciador de tags do Google e você encontrará algum guia ou tutorial. No entanto, há uma chance de que o guia encontrado seja para o Universal Analytics, portanto, talvez seja necessário adaptá-lo às suas necessidades.
Vamos imaginar que, no nosso caso, vemos o logotipo “Vimeo” no canto do reprodutor de vídeo incorporado.
#3.1. Crie uma variável “O player do Vimeo está presente em uma página”
Para rastrear jogadores do Vimeo com GTM em uma página, precisaremos adicionar um código longo ao contêiner. Carregar esse código em todas as páginas não é ideal e afetará a velocidade de carregamento da página , é por isso que devemos ativar esse código APENAS quando o player do Vimeo estiver realmente incorporado nesse site.
Para isso, primeiro precisamos criar uma variável Custom JavaScript (vá em Variables > New > Custom Javascript ) e colar o seguinte código:
função () {
for (var e = document.getElementsByTagName("iframe"), x=0; x < e.length; x++) {
if (/^https?:\/\/player.vimeo.com/.test(e[x].src)) {
retornar verdadeiro;
}
}
retorna falso;
}
Nomeie esta variável como cjs – é o reprodutor do vimeo em uma página .
Se o player do Vimeo estiver embutido na página, esta variável retornará true .
Em seguida, crie um gatilho carregado na janela e use essa variável JavaScript personalizada nele. Se o player do Vimeo estiver presente, esse gatilho será ativado. Se não houver nenhum reprodutor do Vimeo, esse acionador permanecerá silencioso.
#3.2. Ouvinte de eventos automáticos do Vimeo
Agora, é a vez do Vimeo Listener. Um ouvinte é uma função (ou várias funções) construída para continuar procurando por certas interações em uma página. Nesse caso, o ouvinte estará procurando por interações do player do Vimeo. Se detectar um, tornará esses dados visíveis no modo de visualização e depuração.
Crie uma tag HTML personalizada e cole o seguinte código. Os autores originais deste código são Bill Tripple e Bogdan Bistriceanu da Cardinal Path ), mas para torná-lo mais conveniente para o GA4, modifiquei o código (um pouco).
<!--
Tag HTML personalizada do Gerenciador de tags do Google Analytics (V2) para rastreamento de vídeo do Vimeo
Direitos autorais 2016, Cardinal Path, Inc.
Autor original: Bill Tripple < btripple@cardinalpath.com >
Revisado por: Bogdan Bistriceanu < bbistriceanu@cardinalpath.com >
Atualizado por: Julius Fedorovicius < julius@analyticsmania.com > e Richard Outram < Richard.Outram@simmbiotic.com >
Versão 2.1
-->
<script>
var dataLayer = (typeof(dataLayer) !== "undefined" && dataLayer instanceof Array) ? camada de dados : [];
var videoLabels=[];
var últimoP=[];
//declaramos variáveis que conterão informações sobre o vídeo que está sendo reproduzido
var _playerTitle = {}, _playerAuthor = {}, _playerAuthorURL = {}, _playerUploadDate = {};
experimentar{
calor();
}
catch(err){
dataLayer.push({
'evento': 'gtm.error',
'errorMessage': e.message,
'tag': 'Ouvinte de vídeo do Vimeo'
})
}
função init(){
experimentar{
var player=document.getElementsByTagName("iframe");
for (i = 0; i < player.length; ++i) {
var url=player[i].getAttribute("src");
if(/player\.vimeo\.com\/video/.test(url)){ // vimeo iframe encontrado
if(!player[i].hasAttribute("id")){ // falta o atributo id
player[i].setAttribute("id","vimeo_id_"+i); // adiciona o atributo id
}
var urlAtualizado=falso;
if(!/api=/.test(url)){ // verifica se o parâmetro api está no atributo src
url=updateUrl(url,"api",1);
urlAtualizado=verdadeiro;
}
if(!/player_id=/.test(url)){ // verifica se player_id está no atributo src
url=updateUrl(url,"player_id",player[i].getAttribute("id"));
urlAtualizado=verdadeiro;
}
if(urlUpdated){ // repovoa o atributo src com parâmetros adicionados
player[i].setAttribute("src",url)
}
videoLabels[player[i].getAttribute("id")]=player[i].getAttribute("src"); // id para rotular o dicionário
}
}
// Escuta as mensagens do jogador
if (window.addEventListener){
window.addEventListener('message', onMessageReceived, false);
}
outro {
window.attachEvent('onmessage', onMessageReceived, false);
}
}
catch(err){
}
}
function updateUrl(url,param,value){
experimentar{
return url+((/\?/.test(url)) ? "&" : "?")+param+"="+valor;
}
catch(err){
}
}
// Trata as mensagens recebidas do jogador
function onMessageReceived(e) {
experimentar{
var dados = e.dados;
if(tipo de dado === "string"){
dados = JSON.parse(dados);
}
switch (data.evento) {
caso 'pronto':
onPronto(dados);
pausa;
caso 'jogar':
onPlay(dados);
pausa;
caso 'pausa':
onPause(dados);
pausa;
caso 'atualização de horário':
onPlayProgress(dados);
pausa;
}
}
catch(err){
}
}
// Função auxiliar para enviar uma mensagem ao jogador
function post(ação, valor) {
experimentar{
var dados = {
método: ação
};
se (valor) {
data.value = valor;
}
var mensagem = JSON.stringify(dados);
var player = document.getElementsByTagName("iframe");
onde url;
pode saber
for (i = 0; i < player.length; ++i) {
url=player[i].getAttribute("src");
if(/player\.vimeo\.com\/video/.test(url)){
// Verifica se o protocolo existe
prot = player[i].getAttribute('src').split('?')[0].split('//')[0];
// Se o protocolo não existir, então precisa anexar a "url"
if (!prot){
url="https:" + player[i].getAttribute("src").split('?')[0];
}
player[i].contentWindow.postMessage(data, url);
}
}
}
catch(err){
}
}
function getLabel(id){
experimentar{
return videoLabels[id].split('?')[0].split('/').pop();
}
catch(err){
}
}
//nossa função que usará a API oEmbed do Vimeo para recuperar informações adicionais sobre o vídeo
function getVimeoInfo(url, callback) {
var script = document.createElement('script');
script.type = 'texto/javascript';
script.src = url;
document.getElementsByTagName('body')[0].appendChild(script);
}
//a função de retorno de chamada que pega os dados recebidos da API oEmbed do Vimeo e os coloca nos objetos correspondentes
function vimeoCallback(e){
//console.log(e);
_playerTitle[e['video_id']] = e['title'];
_playerAuthor[e['video_id']] = e['author_name']
_playerAuthorURL[e['video_id']] = e['author_url']
_playerUploadDate[e['video_id']] = e['upload_date']
}
função onReady(dados) {
experimentar{
//executa nossa função que consulta a API oEmbed do Vimeo assim que os vídeos incorporados estiverem "prontos"
getVimeoInfo("https://www.vimeo.com/api/oembed.json?url=https://vimeo.com/"+getLabel(data.player_id)+"&callback=vimeoCallback", vimeoCallback);
post('addEventListener', 'play');
post('addEventListener', 'pausa');
post('addEventListener', 'concluir');
post('addEventListener', 'playProgress');
}
catch(err){
}
}
function onPlay(dados){
experimentar{
var t = data.data.duration - data.data.seconds <= 1,5 ? 1 : (Math.floor(data.data.seconds / data.data.duration * 4) / 4).toFixed(2);
dataLayer.push({
evento: "vídeo",
video_action: "reproduzir",
video_url: 'https://vimeo.com/' + getLabel(data.player_id),
video_percent: data.data.percent.toFixed(2) * 100,
video_title: _playerTitle[getLabel(data.player_id)].toLowerCase()
});
}
catch(err){
}
}
function onPause(dados){
experimentar{
var t = data.data.duration - data.data.seconds <= 1,5 ? 1 : (Math.floor(data.data.seconds / data.data.duration * 4) / 4).toFixed(2);
dataLayer.push({
evento: "vídeo",
video_action: "pausa",
video_url: 'https://vimeo.com/' + getLabel(data.player_id),
video_percent: data.data.percent.toFixed(2) * 100,
video_title: _playerTitle[getLabel(data.player_id)].toLowerCase()
});
}
catch(err){
}
}
// Acompanhe o progresso: 25%, 50%, 75%, 100%
function onPlayProgress(dados) {
experimentar{
var t = data.data.duration - data.data.seconds <= 1,5 ? 1 : (Math.floor(data.data.seconds / data.data.duration * 4) / 4).toFixed(2); if (!lastP[data.player_id] || t > lastP[data.player_id]) {
lastP[data.player_id]=t;
if (parseFloat(t) != 0){
dataLayer.push({
evento: "vídeo",
video_action: "progresso",
video_url: 'https://vimeo.com/' + getLabel(data.player_id),
video_percent: t * 100,
video_title: _playerTitle[getLabel(data.player_id)].toLowerCase()
})
}
}
}
catch(err){
}
}
</script>
Não se esqueça de atribuir o acionador carregado de janela criado anteriormente:
Ponto de verificação! Vamos ver o que criamos até agora:
- Um gatilho carregado na janela que verifica se o reprodutor de vídeo do Vimeo está incorporado na página da web (graças a uma variável JavaScript personalizada).
- Um ouvinte de evento automático do Vimeo (como uma tag HTML personalizada) é acionado somente quando o acionador carregado de janela mencionado acima é ativado. Toda vez que ocorre uma interação do player do Vimeo, o ouvinte despacha um evento da camada de dados com os seguintes dados:
- Nome do evento: video (este valor nunca muda)
- video_action (reproduzir, pausar ou progredir)
- URL do vídeo
- video_percent
- Título do vídeo
Como você pode ver, há menos dados (em comparação com o gatilho do Youtube), mas ainda é bastante útil.
Se você quiser testar isso agora, ative o modo de visualização e depuração, atualize a página com o player do Vimeo e tente interagir com ele. Você deve começar a ver eventos de vídeo no lado esquerdo do modo de visualização.
A propósito, o ouvinte do Vimeo rastreia os seguintes limites de vídeo: 25%, 50%, 75%, 100%. Não há evento “completo” aqui.
#3.3. Crie variáveis de camada de dados e um acionador de evento personalizado
Se você deseja transferir alguma informação da camada de dados para outras ferramentas (por exemplo, Google Analytics) com o Google Tag Manager, você precisa “ensinar” o GTM a buscá-la (com a ajuda de variáveis da camada de dados).
Aqui está uma captura de tela da variável video_action.
Faça o mesmo com video_url, video_percent e video_title.
Depois que as variáveis são configuradas, é hora de criar um acionador de evento personalizado. O Vimeo Auto-Event Listener envia todas as interações como eventos da camada de dados em “vídeo” .
dataLayer.push({
evento: "vídeo",
.......
});
Portanto, a próxima coisa que você deve fazer é criar um acionador de evento personalizado que ouça TODOS os eventos de vídeo . Posteriormente, ele será atribuído à tag do Google Analytics.
No GTM, vá para Gatilhos > Novo > Evento personalizado e insira as seguintes configurações:
#3.4. Criar uma tag de evento do Google Analytics 4
Por último, mas não menos importante, o Google Analytics. Agora você precisa enviar um evento e passar os dados correspondentes. Crie uma nova tag, selecione a tag de evento do GA4 como Tipo de tag e insira a seguinte configuração:
O princípio aqui é bastante semelhante ao que fiz com o rastreamento de vídeo do Youtube no capítulo anterior.
- O valor do campo do nome do evento será video_play, video_pause ou video_progress. Isso é possível por causa da variável Data Layer que inseri nesse campo.
- Como temos os parâmetros video_title , video_url e video_percent na camada de dados (e criamos variáveis para eles), também os inseri na tag.
#3.5. teste teste teste
Não se esqueça de testar toda esta configuração. Habilite o modo de visualização e depuração do GTM , vá para uma página com um reprodutor Vimeo incorporado e clique em Reproduzir. A próxima coisa que você deve ver é um evento de vídeo no fluxo de eventos do modo de visualização e depuração. Clique nele e veja se a tag de evento do GA4 foi disparada.
Em caso afirmativo, vá para o Google Analytics 4 DebugView para verificar se você vê os eventos recebidos.
Depois de um tempo, seus dados de eventos também aparecerão nos relatórios padrão do Google Analytics e no Analysis Hub. Mas isso pode levar até 24 horas . Então seja paciente.
Além disso, não se esqueça de registrar os parâmetros como video_percent ou video_title como dimensões personalizadas (se quiser usá-los em seus relatórios do GA4).
#3.6. Todo o processo em poucas palavras
- Criamos uma variável JS personalizada que retorna true se o player do Vimeo estiver incorporado em uma página.
- Em seguida, criamos um gatilho carregado na janela que verifica se o reprodutor de vídeo Vimeo está incorporado na página da web (graças a uma variável JavaScript personalizada)
- Em seguida, criamos uma tag HTML personalizada (um Vimeo Auto-Event Listener). E ele será acionado em todas as páginas em que o player do Vimeo estiver incorporado. Importante: mesmo que você ainda não tenha interagido com o player, essa tag ainda será disparada.
- Toda vez que ocorre uma interação do player do Vimeo, o ouvinte despacha um evento da camada de dados com os seguintes dados:
- Nome do evento: video (este valor nunca muda)
- video_action (reproduzir, pausar ou progredir)
- URL do vídeo
- video_percent
- Título do vídeo
- Você criou 4 variáveis de camada de dados e um acionador de evento personalizado (para o evento de vídeo ).
- Por fim, você criou uma tag de evento GA4 que é acionada no evento de vídeo e enviará os valores dessas 4 variáveis de camada de dados para o Google Analytics.
#4. Acompanhamento do player de vídeo HTML5 com GA4
Como já mencionei, diferentes reprodutores de vídeo exigem diferentes ouvintes de eventos automáticos se você quiser acompanhar o envolvimento deles. Mas, em geral, o princípio da implementação é bastante semelhante ao que já fizemos com o reprodutor Vimeo.
- Crie uma variável JavaScript personalizada que verifique se o player de vídeo está presente em uma página.
- Você adiciona uma tag HTML personalizada (com o código do ouvinte). Esse ouvinte procurará interações de vídeo de um determinado tipo de reprodutor de vídeo. Dispare esta tag somente se a variável Custom JavaScript retornar true (isso significa que o player está presente em uma página).
- Em seguida, esse ouvinte enviará os dados de engajamento de vídeo para a camada de dados.
- Você precisará criar variáveis de camada de dados para acessar esses dados personalizados.
- Além disso, você precisará criar um acionador de evento personalizado.
- Por fim, você precisará criar uma tag de evento do GA4 que acione uma dataLayer.push e enviar os dados de engajamento de vídeo para o GA.
Como exemplo, você pode dar uma olhada em outro tipo popular de reprodutor de vídeo, o vídeo HTML5 genérico. Leia este guia para saber mais sobre como rastrear esses jogadores com GA4 e GTM.
#5. Três receitas GTM para rastreamento de vídeo com GA4
Quem acompanha o Analytics Mania há algum tempo sabe que compilei uma biblioteca de templates de containers GTM prontos (chamados de receitas) . Uma parte sólida dessas receitas também envolve rastreamento de vídeo.
No entanto, devido à falta de tempo (porque tenho que dar suporte a muitos alunos dos meus cursos de GTM ), muitas dessas receitas ainda funcionam apenas com o Universal Analytics.
Mas espero que, no futuro, eu tenha a chance de atualizar todos eles para oferecer suporte ao GA4 também. Um passo de cada vez.
Rastrear vídeos com Google Analytics 4 e GTM: palavras finais
Existem muitas maneiras de rastrear vídeos com o Google Analytics e o Gerenciador de tags do Google. Mas essas formas/métodos dependem de que tipo de jogador você está lidando. É um player de vídeo do Youtube? Vimeo? Algo mais?
Primeiro, você precisa investigar o player (e seu fornecedor) e, em seguida, precisa encontrar o método de rastreamento certo para ele.
Nesta postagem do blog, compartilhei soluções para 3 jogadores (Youtube, Vimeo, HTML5). Se você estiver lidando com algum outro jogador, descubra o nome desse jogador. Depois de fazer isso, faça uma pesquisa no Google e continue procurando por algo como “[insira o nome do player de vídeo] rastreando com o gerenciador de tags do Google”.
As chances são de que você terá sorte e encontrará a solução necessária.