Wascer DB

O Wascer DB é um banco de dados NoSQL integrado diretamente ao ambiente Server:Side Google Tag Manager (sGTM) da Wascer. Ele fornece armazenamento Key:Value persistente no lado do servidor, eliminando a dependência de cookies de terceiros e de serviços externos como Firestore ou Supabase.

Com o bloqueio crescente de cookies de terceiros pelos navegadores e as restrições impostas por legislações como LGPD e GDPR, a persistência de dados no client:side se tornou cada vez mais frágil. A Wascer DB resolve isso ao transferir o armazenamento de estado para o servidor. Seus dados não são afetados por políticas de bloqueio de cookies, extensões de navegador ou limpezas de cache do usuário.

Na prática, você armazena documentos JSON organizados por chaves únicas dentro de coleções. Cada documento pode conter até 1 MB de dados estruturados, e seu container suporta até 10 milhões de documentos. A integração com o sGTM é feita via templates nativos (Writer Tag, Store Read Variable, reStore Variable) ou via API HTTP direta sem necessidade de infraestrutura adicional.

Painel Wascer — seção Banco de Dados com status Ativo, coleções e métricas do contêiner

Benefícios

• Persistência server-side: dados armazenados no servidor, imunes a bloqueio de cookies, ITP/ETP e ad blockers.
• Identificação cross-session: reconhece usuários ao longo de múltiplas sessões sem depender de mecanismos client:side. Ideal para janelas de atribuição longas.
• Conformidade com LGPD/GDPR: exclusão sob demanda e anonimização. Atende requisições de titulares (Art. 18 LGPD / Art. 17 GDPR) diretamente via API ou painel.
• Latência mínima: o Wascer DB reside na mesma infraestrutura do seu container sGTM. As operações de leitura e escrita respondem em milissegundos, sem round:trips para serviços externos.
• Zero configuração de infra: não é necessário provisionar bancos de dados, configurar credenciais OAuth ou gerenciar conexões. Ativação em um clique.
• Templates nativos no sGTM: Writer Tag, Store Read Variable e ReStore Variable prontos para uso. Cenários comuns não exigem código customizado.
• API HTTP completa: GET, POST, PATCH e DELETE para integração programática com qualquer backend, CRM ou pipeline de dados.
• Segurança: dados nunca expostos ao navegador do usuário. Autenticação via API Key. Isolamento por container.
• Custo incluso: disponível nos planos Pro e superiores sem cobrança adicional por volume de operações.

Como funciona

Arquitetura KeyValue no sGTM

O Wascer DB opera como um banco de dados de documentos JSON, organizado por chaves únicas

(Document Keys) dentro de coleções (Collections). A estrutura é simples e direta:

• Coleções: agrupam documentos por contexto (ex.: user_profiles, attribution, capping).
• Documentos: objetos JSON identificados por uma chave única. Tamanho máximo: 1MB.
• Campos: acessíveis via key path (ex.: data.segment, data.consent.analytics).

Modelo de dados

{
  "document_key": "user_abc123",
  "collection": "user_profiles",
  "data": {
    "email_hash": "a1b2c3d4e5f6",
    "first_seen": "2026-01-15T10:30:00Z",
    "total_sessions": 14,
    "ltv": 2450.00,
    "consent": {"analytics": true, "marketing": false}
  },
}

Fluxo de dados

1. O navegador do usuário envia uma requisição (page view, evento) para o endpoint sGTM da Wascer.
2. O container sGTM processa o evento e, via Tag ou Variable template, interage com o Wascer DB.
3. A Wascer DB grava ou recupera o documento associado à chave informada (User ID, Client ID).
4. Os dados recuperados são injetados no evento antes do disparo das tags de destino (Google Analytics 4, Meta Conversions API, TikTok Events API, etc.).

Ativar o Wascer DB

1. Acesse o painel da Wascer em wascer.com e faca login com suas credenciais.
2. Selecione o contêiner sGTM no qual deseja habilitar o Wascer DB.
3. Navegue até a seção “Banco de Dados” no menu lateral do container (abaixo de “Boosters”).
4. Verifique o status: no cabeçalho do container, o campo Banco de Dados deve exibir Ativo, caso não estiver ativado, basta ativá-lo.
5. Confirme a ativação: o Wascer DB estará disponível imediatamente para uso via templates e API.

Painel Wascer — seção Banco de Dados ativa

Criar Coleções

Após a ativação, crie coleções para organizar seus documentos. Uma coleção default é criada automaticamente.

1. Na seção Banco de Dados, clique no botão “+ Nova” ao lado de “Collections”.
2. No modal Nova Collection, informe o nome. Apenas letras, números, hífen e underscore.
3. Clique em “Criar” para confirmar.

Modal de criação de nova collection — campo com placeholder ‘ex: users’

Modal preenchido com o nome ‘Wascer’ pronto para criação

Gerenciamento via Dashboard

Após a ativação, o painel do Wascer DB permite:

• Visualizar documentos: navegue por coleções e inspecione os dados armazenados.
• Pesquisar documentos: utilize a barra “Buscar documento por chave…” ou os filtros avançados.
• Monitorar métricas: total de documentos, número de coleções, página atual e itens por página.
• Baixar templates: clique em “templates” para importar os templates oficiais no sGTM.

Importar Templates no sGTM

Apos a ativação, importe os templates oficiais clicando no botão “Baixar templates” no painel do Banco de Dados: Os templates tambem estao disponiveis nos repositorios oficiais do GitHub:

Template	Tipo	Função
Wascer Store Writer	Tag	Grava dados no Store usando uma Document Key — GitHub
Wascer Store Read	Variable Re	cupera o valor de um campo via Document ID, Field Name e Collection — GitHub

Passo a Passo: Importar e Configurar Templates no sGTM

Esta seção detalha o processo completo de importação dos templates Wascer Store Writer (Tag) e Wascer Store Read (Variable) no Google Tag Manager Server:Side, com capturas de tela de cada etapa.

Etapa 1: Baixar os templates no painel Wascer

1. Acesse o painel da Wascer e selecione o container sGTM desejado. No cabeçalho, verifique se o status está como Running e o Banco de Dados como Ativo.

2. Acesse a página Wascer Store Você verá todos os templates disponíveis para o GTM Server:Side: Wascer Store Writer (Server Tag), Wascer Store Read (Server Variable), Data Client Wascer, Firestore Writer, Google Sheets e Google Offline.

3. Clique em “Baixar .zip” nos templates que deseja importar. Para o Wascer Store, baixe o Wascer DB Writer e o Wascer Store Read.

Página Templates — todos os templates disponíveis com botão “Baixar .zip”

Repositórios dos templates no GitHub:

•  Wascer Store Writer (Server Tag): https://github.com/sourei:tech/wascer:store:writer

•  Wascer Store Read (Server Variable): https://github.com/soureiBR/wascer-store-read

•  Data Client Wascer (Server Client): https://github.com/soureiBR/Data:Client:Wascer

•  Firestore Writer Wascer (Server Tag): https://github.com/soureiBR/Firestore:Writer:Wascer

•  Google Sheets (Server Tag): https://github.com/soureiBR/google:sheets:template

•  Google Offline (Server Tag): https://github.com/soureiBR/google:data:manager:template

Etapa 2: Importar o modelo de Tag (Wascer Store Writer)

4. Abra o sGTM (clique em “Acessar GTM” no painel Wascer). No menu lateral do espaço de trabalho, clique em “Modelos”.

Workspace do sGTM — seta indicando “Modelos” no menu lateral esquerdo

5. Na página Modelos, você verá três seções: Modelos de cliente, Modelos de tag e Modelos de variável. Clique no botão “Novo” em “Modelos de tag”.

Página Modelos — botão “Novo” destacado na seção “Modelos de tag”

6. No Editor de modelos, clique no menu de três pontos (canto superior direito) e selecione “Importar”.

Editor de modelos — menu dropdown com opção “Importar” destacada

7. Selecione o arquivo .tpl do Wascer Store Writer (extraído do .zip baixado anteriormente). O template será carregado automaticamente com nome, descrição e ícone. Baixe em Wascer_Store_writer

Template Wascer Store Writer importado — nome, descrição e ícone carregados, checkbox dos Termos de Serviço marcada e botão “Salvar” destacado

Etapa 3: Importar o modelo de Variável (Wascer Store Read)

1. Volte a pagina Modelos. Agora clique no botão “Novo” em “Modelos de variável”.

Página Modelos — botão “Novo” destacado na seção “Modelos de variável”

2. No Editor de modelos de variável, clique no menu de três pontos e selecione “Importar”.

Editor de modelos de variável — menu dropdown com opção “Importar”

3. Selecione o arquivo .tpl do Wascer Store Read. O template será carregado com o nome “Wascer Store Read” e a descrição “The value is set to the value from a key in a Wascer Store document.” Baixe em Wascer_Store_Read

4. Marque a checkbox dos Termos de Serviço e clique em “Salvar”.

Wascer Store Read importado — nome, descrição e checkbox de Termos marcada

5. Confirme a importação. O modelo “Wascer Store Read” aparecerá na lista de Modelos de variável.

Página Modelos — “Wascer Store Read” listado em Modelos de variável

Etapa 4: Criar uma Tag usando o Wascer Store Writer

1. No menu lateral, clique em “Tags” e depois em “Nova” para criar uma nova tag.

2. Em “Tipo de tag”, selecione “Wascer Store Writer” (modelo personalizado que você importou).

3. Em “Acionamento”, adicione o acionador de disparo desejado (ex.: “All Pages” para disparar em todas as páginas).

4. De um nome a tag (ex.: “Wascer_Store_Writer_Tag”) e clique em “Salvar”.

Configuração da tag Wascer Store Writer com acionador “All Pages”

Lista de Tags — “Wascer_Store_Writer_Tag” criada com acionador All Pages

Etapa 5: Criar e configurar a Variável Wascer Store Read

1. No menu lateral, clique em “Variáveis” e depois em “Nova” (na seção Variáveis definidas pelo usuário).

2. Em “Tipo de variável”, selecione “Wascer Store Read” (modelo personalizado importado).

3. Preencha os campos:

•  Document ID: o identificador do documento (aceita variáveis, ex.: {{Document_ID}})

•  Field Name: o nome do campo que deseja recuperar (ex.: page_view)

•  Collection (optional) : a coleção onde o documento está (ex.: Wascer)

Variável Wascer Store Read preenchida: Document ID {{Document_ID}}, Field Name “page_view”, Collection “Wascer”

4. De um nome a variável (ex.: “Wascer_Store_Read”) e clique em “Salvar”.

Pronto! Seus templates Wascer Store estão configurados no sGTM. A tag Wascer Store Writer grava dados no banco de dados a cada disparo, e a variável Wascer Store Read poderá ser utilizada em qualquer tag ou acionador para ler dados armazenados.

5. Exemplos de implementação

Base URL: ‘https://{conteiner_url}/wascer-api/{api_key}/v1/store/{função}

Documentação sobre a api: https://docs.wascer.com

1. Escrita de dados — POST

Grave um documento no Wascer Store usando uma requisição HTTP POST.

Endpoint:

POST https://api.store.wascer.com/v2/documents

Headers:

Content-Type: application/json
Authorization: Bearer <WASCER_STORE_API_KEY>

Request Body:

{
"collection": "user_profiles", 
"document_key": "uid_7f3a9c2e",
"data": {"email_hash": "sha256_a1b2c3d4e5f6", 
"first_seen": "2026-05-15T10:30:00Z",
"segment": "new_customer",
"consent_analytics": true},
}

Response (201 Created):

{
"status": "created", 
"document_key": "uid_7f3a9c2e", 
"collection": "user_profiles",
"expires_at": "2026-08-13T10:30:00Z"
}

2. Leitura de dados — GET

Documento completo:

GET 
https://api.store.wascer.com/v2/documents/user_profiles/uid_7f3a9c2e

Campo específico via Key Path:

GET
https://api.store.wascer.com/v2/documents/user_profiles/uid_7f3a9c2e?field=data.segment

Response (campo específico):
{
"document_key": "uid_7f3a9c2e", "field": "data.segment", "value": "new_customer"
}

3. Atualização parcial — PATCH

Endpoint:

PATCH https://api.store.wascer.com/v2/documents/user_profiles/uid_7f3a9c2e

Request Body:

{
"data": {"segment": "returning_customer",
"total_sessions": 5,
"ltv": 349.90
}
}

4. Exclusão — DELETE

DELETE https://api.store.wascer.com/v2/documents/user_profiles/uid_7f3a9c2e

Endpoint:

Response: 204 No Content.

5. Leitura via sGTM Variable Template (JavaScript Sandboxed)

const sendHttpGet = require('sendHttpGet'); const JSON = require('JSON');

const STORE_API = 'https://api.store.wascer.com/v2/documents'; const API_KEY = data.apiKey;

const collection = data.collection; const documentKey = data.documentKey; const fieldPath = data.fieldPath;

const url = STORE_API + '/' + collection + '/' + documentKey

+ (fieldPath ? '?field=' + fieldPath : '');

sendHttpGet(url, { headers: {

'Authorization': 'Bearer ' + API_KEY, 'Content-Type': 'application/json'

},

timeout: 2000

}).then(function(result) {

if (result.statusCode === 200) { const body = JSON.parse(result.body);

return fieldPath ? body.value : body.data;

}

return undefined;

});

5. Escrita via sGTM Tag Template (JavaScript Sandboxed)

const sendHttpRequest = require('sendHttpRequest'); const JSON = require('JSON');
const getTimestampMillis = require('getTimestampMillis');

const STORE_API = 'https://api.store.wascer.com/v2/documents'; const API_KEY = data.apiKey;

const payload = { collection: data.collection,
document_key: data.documentKey, data: {
event_name: data.eventName, timestamp: getTimestampMillis(), user_agent: data.userAgent
},
};

sendHttpRequest(STORE_API, { method: 'POST',
headers: {
'Authorization': 'Bearer ' + API_KEY, 'Content-Type': 'application/json'
},
timeout: 2000
}, JSON.stringify(payload)).then(function(result) {
if (result.statusCode >= 200 && result.statusCode < 300) { data.gtmOnSuccess();
} else { data.gtmOnFailure();
}
});

7. Exemplo completo: Frequency Capping Server:Side

const sendHttpGet = require('sendHttpGet');
const sendHttpRequest = require('sendHttpRequest'); const JSON = require('JSON');
const getTimestampMillis = require('getTimestampMillis');

const STORE_API = 'https://api.store.wascer.com/v2/documents'; const API_KEY = data.apiKey;
const collection = 'capping';
const documentKey = 'cap_' + data.transactionId;

// 1. Verificar se o evento ja foi registrado sendHttpGet(STORE_API + '/' + collection + '/' + documentKey, { headers: { 'Authorization': 'Bearer ' + API_KEY },
timeout: 2000
}).then(function(result) {

if (result.statusCode === 404) {
// 2. Primeiro disparo — gravar e disparar a tag var payload = JSON.stringify({
collection: collection, document_key: documentKey, data: {
event: data.eventName, fired_count: 1,
last_fired: getTimestampMillis()
},
});

sendHttpRequest(STORE_API, { method: 'POST',
headers: {
'Authorization': 'Bearer ' + API_KEY, 'Content-Type': 'application/json'
},
timeout: 2000
}, payload).then(function() { data.gtmOnSuccess(); // Tag dispara
});

} else if (result.statusCode === 200) {
// 3. Evento ja disparado — bloquear data.gtmOnFailure(); // Tag NAO dispara
}
});

Verifica se um evento já foi disparado antes de acionar a tag de destino. Impede disparos duplicados de conversão para Meta Conversions API ou Google Ads.

1. Atribuição cross:session com GCLID/FBCLID

Um usuário acessa seu e:commerce pela primeira vez via campanha do Google Ads. O Wascer Store grava o gclid associado ao seu identificador. Dias depois, o mesmo usuário retorna por acesso direto e converte. O container sGTM recupera o gclid original do Wascer Store e atribui corretamente a conversão à campanha original — mesmo que os cookies do navegador tenham sido limpos.

Documento armazenado:

{
"document_key": "uid_7f3a9c2e", "collection": "attribution", "data": {
"gclid": "EAIaIQobChMI...",
"fbclid": "IwAR3x...", "first_touch_source": "google", "first_touch_medium": "cpc", "first_touch_campaign": "black_friday_2026"
},
}

2. Frequency capping de conversões

Limite o disparo do pixel de conversão do Meta Conversions API a no máximo 1 vez por transação, mesmo que o evento purchase seja enviado múltiplas vezes devido a retentativas do client:side. O Wascer Store registra cada transação disparada e bloqueia duplicatas automaticamente.

3. Enriquecimento de dados em tempo real

Ao receber um evento add_to_cart, o container sGTM consulta o Wascer Store para recuperar o segmento do cliente (vip, recorrente, novo), LTV e tier de fidelidade. Essas informações são injetadas como parâmetros customizados no evento enviado ao Google Analytics 4 e Meta Conversions API, sem necessidade de chamadas externas a CRMs ou CDPs.

Autenticacao: Header Authorization: Bearer <WASCER_STORE_API_KEY>

Endpoints

Método	Endpoint	Descrição
POST	/v2/documents	Cria um novo documento
GET	/v2/documents/{collection}/{key}	Recupera um documento
GET	/v2/documents/{collection}/{key}?field={path}	Recupera um campo específico
PATCH	/v2/documents/{collection}/{key}	Atualiza campos de um documento
DELETE	/v2/documents/{collection}/{key}	Exclui um documento

Limites

Recurso	Limite
Tamanho máximo por documento	1 MB
Total de documentos por container	10.000.000
Timeout recomendado	2.000 ms

O Wascer DB está disponível nos seguintes planos:

Plano	Wascer DB	Documentos	Observação
Free	Incluso	Até 10Mil	Acesso completo via templates e API
Starter	Incluso	Até 1M	Acesso completo via templates e API
Pro	Incluso	Até 10M	Acesso completo via templates e API
Business	Incluso	Até 10M	Acesso completo + suporte prioritário
Enterprise	Incluso	Customizado	Limites sob consulta + SLA dedicado

Para implementações customizadas ou necessidades específicas de volume, entre em contato com a equipe comercial da Wascer.