Alertas de anomalías en Google Ads con Scripts y un modelo: el código completo

/**
 * Alertas de anomalías y resumen semanal de pauta
 * Google Ads Scripts + modelo de lenguaje, con compuerta de cifras y cola de aprobación.
 *
 * Publicado en https://velumi.io/guias/pauta-alertas-anomalias/ · versión 1.0 · 2026-09-19
 * Uso libre, sin garantía. Leé la guía antes de programarlo.
 *
 * QUÉ HACE
 *  1. Recorre las campañas de la cuenta y compara los últimos 7 días (hasta ayer) contra los 28 días
 *     previos, normalizados a 7, en costo, conversiones, CPA y CTR.
 *  2. Marca anomalías con un umbral relativo configurable y una regla de mínimo de datos: si la base
 *     no tiene datos suficientes, la campaña queda como «sin datos», no como anomalía.
 *  3. Arma la tabla del resumen semanal y, si hay clave, le pide a un modelo que la redacte.
 *     Compuerta de cifras: todo número del texto tiene que existir en la tabla; si no, se reintenta
 *     una vez y a la segunda se envía la tabla sin narrativa.
 *  4. Envía el resultado por email a la persona de cuentas (la cola de aprobación). Nunca al cliente.
 *
 * QUÉ NO HACE
 *  - No modifica pujas, presupuestos, estados, anuncios ni palabras clave. Las únicas llamadas a
 *    AdsApp son campaigns(), currentAccount() y getExecutionInfo(): todas de lectura.
 *  - No escribe al cliente ni publica nada. El único destinatario es CONFIG.destinatario.
 */

// ---------------------------------------------------------------------------------------------
// 1. Configuración: lo único que se edita por cliente.
// ---------------------------------------------------------------------------------------------
const CONFIG = {
  cliente: 'Acme',                          // nombre que verá la persona de cuentas en el asunto
  destinatario: 'cuentas@tuagencia.com',    // quien aprueba; se admiten varios separados por coma
  umbral: 0.30,                             // variación relativa que cuenta como anomalía (0.30 = 30 %)
  minimo: {                                 // mínimo de datos en la base de 28 días; por debajo, «sin datos»
    clics: 100,
    costo: 50,                              // en la moneda de la cuenta
    conversiones: 5,                        // requerido solo para juzgar conversiones y CPA
  },
  ventanas: { actual: 7, base: 28 },        // días; la base se normaliza a la ventana actual
  incluirPausadas: false,                   // true: también compara campañas en pausa
  modelo: {
    clave: '',                              // clave de API de Anthropic; vacía = tabla sin narrativa
    id: 'claude-opus-5',
    maxTokens: 1500,
    reintentos: 1,                          // reintentos si la compuerta de cifras rechaza el texto
  },
  hojaCola: '',                             // URL de una hoja de cálculo para la cola; vacía = solo email
  hojaColaPestana: 'cola',
};

// ---------------------------------------------------------------------------------------------
// 2. Punto de entrada
// ---------------------------------------------------------------------------------------------
function main() {
  const cuenta = AdsApp.currentAccount();
  const zona = cuenta.getTimeZone();
  const moneda = cuenta.getCurrencyCode();
  const rango = rangos(new Date(), zona, CONFIG.ventanas);
  const filas = leerCampanas(rango);
  const resumen = armarResumen(filas, rango, moneda, CONFIG);
  const tabla = tablaTexto(resumen);

  let compuerta = { texto: null, motivo: 'sin clave: se envía la tabla sin narrativa', intentos: 0, uso: null };
  if (CONFIG.modelo.clave) compuerta = redactarConCompuerta(tabla, CONFIG.modelo);

  entregar(resumen, tabla, compuerta);
}

// ---------------------------------------------------------------------------------------------
// 3. Lectura de Google Ads (solo lectura)
// ---------------------------------------------------------------------------------------------

// Ventanas en YYYYMMDD para getStatsFor y en YYYY-MM-DD para el texto. Termina ayer: hoy está incompleto.
function rangos(hoy, zona, ventanas) {
  const DIA = 24 * 60 * 60 * 1000;
  const f = function (d, formato) { return Utilities.formatDate(d, zona, formato); };
  const dia = function (n) { return new Date(hoy.getTime() - n * DIA); };
  const actualDesde = dia(ventanas.actual);
  const actualHasta = dia(1);
  const baseDesde = dia(ventanas.actual + ventanas.base);
  const baseHasta = dia(ventanas.actual + 1);
  return {
    actual: { desde: f(actualDesde, 'yyyyMMdd'), hasta: f(actualHasta, 'yyyyMMdd'), desdeIso: f(actualDesde, 'yyyy-MM-dd'), hastaIso: f(actualHasta, 'yyyy-MM-dd') },
    base: { desde: f(baseDesde, 'yyyyMMdd'), hasta: f(baseHasta, 'yyyyMMdd'), desdeIso: f(baseDesde, 'yyyy-MM-dd'), hastaIso: f(baseHasta, 'yyyy-MM-dd') },
    dias: ventanas,
  };
}

function leerStats(s) {
  return { costo: s.getCost(), clics: s.getClicks(), impresiones: s.getImpressions(), conversiones: s.getConversions() };
}

function leerCampanas(rango) {
  let selector = AdsApp.campaigns();
  if (!CONFIG.incluirPausadas) selector = selector.withCondition('campaign.status = ENABLED');
  const iterador = selector.get();
  const filas = [];
  while (iterador.hasNext()) {
    const c = iterador.next();
    filas.push({
      id: String(c.getId()),
      nombre: c.getName(),
      habilitada: c.isEnabled(),
      actual: leerStats(c.getStatsFor(rango.actual.desde, rango.actual.hasta)),
      base: leerStats(c.getStatsFor(rango.base.desde, rango.base.hasta)),
    });
  }
  return filas;
}

// ---------------------------------------------------------------------------------------------
// 4. Lógica de anomalías (funciones puras: se prueban sin Google Ads)
// ---------------------------------------------------------------------------------------------

function derivar(p) {
  return {
    costo: p.costo,
    clics: p.clics,
    impresiones: p.impresiones,
    conversiones: p.conversiones,
    cpa: p.conversiones > 0 ? p.costo / p.conversiones : null,
    ctr: p.impresiones > 0 ? p.clics / p.impresiones : null,
  };
}

// La base de 28 días se lleva a la escala de la ventana actual (7 días): se comparan semanas con semanas.
function normalizarBase(base, ventanas) {
  const factor = ventanas.actual / ventanas.base;
  return { costo: base.costo * factor, clics: base.clics * factor, impresiones: base.impresiones * factor, conversiones: base.conversiones * factor };
}

function variacion(actual, base) {
  if (actual === null || base === null || base === 0) return null;
  return (actual - base) / base;
}

function evaluarCampana(fila, config) {
  const faltan = [];
  if (fila.base.clics < config.minimo.clics) faltan.push('clics');
  if (fila.base.costo < config.minimo.costo) faltan.push('costo');
  const suficiente = faltan.length === 0;
  const conversionesJuzgables = suficiente && fila.base.conversiones >= config.minimo.conversiones;

  const actual = derivar(fila.actual);
  const base = derivar(normalizarBase(fila.base, config.ventanas));
  const cambio = {
    costo: variacion(actual.costo, base.costo),
    conversiones: variacion(actual.conversiones, base.conversiones),
    cpa: variacion(actual.cpa, base.cpa),
    ctr: variacion(actual.ctr, base.ctr),
  };

  const anomalias = [];
  const marcar = function (metrica, tipo, valor, gravedad) { anomalias.push({ metrica: metrica, tipo: tipo, variacion: valor, gravedad: gravedad }); };
  const supera = function (v) { return v !== null && Math.abs(v) >= config.umbral; };

  if (suficiente) {
    if (base.costo > 0 && actual.costo === 0) marcar('costo', 'sin_gasto', -1, 'alta');
    else if (supera(cambio.costo)) marcar('costo', cambio.costo > 0 ? 'sube' : 'baja', cambio.costo, 'media');

    if (conversionesJuzgables) {
      if (actual.conversiones === 0) marcar('conversiones', 'sin_conversiones', -1, 'alta');
      else {
        if (supera(cambio.conversiones)) marcar('conversiones', cambio.conversiones > 0 ? 'sube' : 'baja', cambio.conversiones, cambio.conversiones < 0 ? 'alta' : 'media');
        if (supera(cambio.cpa)) marcar('cpa', cambio.cpa > 0 ? 'sube' : 'baja', cambio.cpa, cambio.cpa > 0 ? 'alta' : 'media');
      }
    }

    if (supera(cambio.ctr)) marcar('ctr', cambio.ctr > 0 ? 'sube' : 'baja', cambio.ctr, 'media');
  }

  return {
    id: fila.id,
    nombre: fila.nombre,
    habilitada: fila.habilitada,
    actual: actual,
    base: base,
    cambio: cambio,
    anomalias: anomalias,
    suficiente: suficiente,
    conversionesJuzgables: conversionesJuzgables,
    faltan: faltan,
  };
}

function armarResumen(filas, rango, moneda, config) {
  const campanas = filas.map(function (f) { return evaluarCampana(f, config); });
  const peso = { alta: 2, media: 1 };
  const gravedadMax = function (c) { return c.anomalias.reduce(function (m, a) { return Math.max(m, peso[a.gravedad]); }, 0); };
  campanas.sort(function (a, b) { return gravedadMax(b) - gravedadMax(a) || b.actual.costo - a.actual.costo; });

  const sumar = function (campo, periodo) { return campanas.reduce(function (t, c) { return t + c[periodo][campo]; }, 0); };
  const totales = {
    actual: derivar({ costo: sumar('costo', 'actual'), clics: sumar('clics', 'actual'), impresiones: sumar('impresiones', 'actual'), conversiones: sumar('conversiones', 'actual') }),
    base: derivar({ costo: sumar('costo', 'base'), clics: sumar('clics', 'base'), impresiones: sumar('impresiones', 'base'), conversiones: sumar('conversiones', 'base') }),
  };
  totales.cambio = {
    costo: variacion(totales.actual.costo, totales.base.costo),
    conversiones: variacion(totales.actual.conversiones, totales.base.conversiones),
    cpa: variacion(totales.actual.cpa, totales.base.cpa),
    ctr: variacion(totales.actual.ctr, totales.base.ctr),
  };
  const nAnomalias = campanas.reduce(function (n, c) { return n + c.anomalias.length; }, 0);
  const nAltas = campanas.reduce(function (n, c) { return n + c.anomalias.filter(function (a) { return a.gravedad === 'alta'; }).length; }, 0);
  return {
    cliente: config.cliente,
    moneda: moneda,
    rango: rango,
    umbral: config.umbral,
    minimo: config.minimo,
    campanas: campanas,
    totales: totales,
    conteo: { campanas: campanas.length, conAnomalias: campanas.filter(function (c) { return c.anomalias.length > 0; }).length, anomalias: nAnomalias, altas: nAltas, sinDatos: campanas.filter(function (c) { return !c.suficiente; }).length },
  };
}

// ---------------------------------------------------------------------------------------------
// 5. La tabla: única fuente de cifras para el modelo y para el email
// ---------------------------------------------------------------------------------------------

function num(v, decimales) {
  if (v === null || v === undefined || isNaN(v)) return 'sin dato';
  return Number(v).toFixed(decimales);
}
function pct(v, decimales) {
  if (v === null || v === undefined || isNaN(v)) return 'sin dato';
  return (v * 100).toFixed(decimales) + '%';
}
function pctSigno(v) {
  if (v === null || v === undefined || isNaN(v)) return 'sin dato';
  const p = (v * 100).toFixed(0);
  return (v > 0 ? '+' : '') + p + '%';
}

function tablaTexto(r) {
  const L = [];
  L.push('RESUMEN SEMANAL DE PAUTA · ' + r.cliente);
  L.push('Ventana actual: ' + r.rango.actual.desdeIso + ' a ' + r.rango.actual.hastaIso + ' (' + r.rango.dias.actual + ' dias)');
  L.push('Base: ' + r.rango.base.desdeIso + ' a ' + r.rango.base.hastaIso + ' (' + r.rango.dias.base + ' dias, promediados a ' + r.rango.dias.actual + ')');
  L.push('Moneda: ' + r.moneda + ' · Umbral de anomalia: ' + pct(r.umbral, 0) + ' · Minimo de datos en la base: ' + r.minimo.clics + ' clics, ' + num(r.minimo.costo, 0) + ' de costo, ' + r.minimo.conversiones + ' conversiones');
  L.push('Campanas analizadas: ' + r.conteo.campanas + ' · Con anomalias: ' + r.conteo.conAnomalias + ' · Anomalias: ' + r.conteo.anomalias + ' (altas: ' + r.conteo.altas + ') · Sin datos suficientes: ' + r.conteo.sinDatos);
  L.push('');
  L.push('TOTALES (actual | base semanal | variacion)');
  L.push('Costo: ' + num(r.totales.actual.costo, 2) + ' | ' + num(r.totales.base.costo, 2) + ' | ' + pctSigno(r.totales.cambio.costo));
  L.push('Conversiones: ' + num(r.totales.actual.conversiones, 1) + ' | ' + num(r.totales.base.conversiones, 1) + ' | ' + pctSigno(r.totales.cambio.conversiones));
  L.push('CPA: ' + num(r.totales.actual.cpa, 2) + ' | ' + num(r.totales.base.cpa, 2) + ' | ' + pctSigno(r.totales.cambio.cpa));
  L.push('CTR: ' + pct(r.totales.actual.ctr, 2) + ' | ' + pct(r.totales.base.ctr, 2) + ' | ' + pctSigno(r.totales.cambio.ctr));
  L.push('');
  L.push('ANOMALIAS (campana · metrica · tipo · variacion · gravedad)');
  let hay = false;
  r.campanas.forEach(function (c) {
    c.anomalias.forEach(function (a) {
      hay = true;
      L.push('- ' + c.nombre + ' · ' + a.metrica + ' · ' + a.tipo + ' · ' + pctSigno(a.variacion) + ' · ' + a.gravedad);
    });
  });
  if (!hay) L.push('- ninguna');
  L.push('');
  L.push('POR CAMPANA (costo actual | base; conversiones actual | base; CPA actual | base; CTR actual | base)');
  r.campanas.forEach(function (c) {
    const estado = c.suficiente ? '' : ' [SIN DATOS SUFICIENTES: ' + c.faltan.join(', ') + ']';
    L.push('- ' + c.nombre + estado + ': costo ' + num(c.actual.costo, 2) + ' | ' + num(c.base.costo, 2) +
      '; conv ' + num(c.actual.conversiones, 1) + ' | ' + num(c.base.conversiones, 1) +
      '; CPA ' + num(c.actual.cpa, 2) + ' | ' + num(c.base.cpa, 2) +
      '; CTR ' + pct(c.actual.ctr, 2) + ' | ' + pct(c.base.ctr, 2));
  });
  return L.join('\n');
}

// ---------------------------------------------------------------------------------------------
// 6. Compuerta de cifras: el modelo redacta, el código verifica
// ---------------------------------------------------------------------------------------------

// Extrae los números de un texto. Ignora fechas (YYYY-MM-DD, DD/MM/YYYY) y admite coma decimal.
function numerosDeTexto(texto) {
  const sinFechas = String(texto).replace(/\d{4}-\d{2}-\d{2}/g, ' ').replace(/\d{2}\/\d{2}\/\d{4}/g, ' ');
  const crudos = sinFechas.match(/\d+(?:[.,]\d+)?/g) || [];
  return crudos.map(function (c) { return { crudo: c, valor: parseFloat(c.replace(',', '.')) }; });
}

// Tolerancia (criterio propio, la misma de la plantilla de reportes): absoluta 0.05 o relativa 0.1 %;
// para valores menores que uno rige solo la relativa.
function coincide(valor, permitido) {
  const a = Math.abs(valor);
  const b = Math.abs(permitido);
  const limite = b < 1 ? 0.001 * b : Math.max(0.05, 0.001 * b);
  return Math.abs(a - b) <= limite;
}

function verificarCifras(texto, permitidos) {
  const huerfanas = [];
  let verificadas = 0;
  numerosDeTexto(texto).forEach(function (n) {
    const ok = permitidos.some(function (p) { return coincide(n.valor, p.valor); });
    if (ok) verificadas++; else huerfanas.push(n.crudo);
  });
  const muletillas = String(texto).match(/\b(aproximadamente|alrededor de|cerca de|estimamos)\b\s+\d/gi) || [];
  return { ok: huerfanas.length === 0 && muletillas.length === 0, verificadas: verificadas, huerfanas: huerfanas, muletillas: muletillas };
}

// El prompt no contiene ningún dígito: todas las cifras entran por la tabla.
const INSTRUCCIONES = [
  'Sos analista de pauta digital en una agencia de marketing de Latinoamerica. Redactas para la persona de cuentas, no para el cliente.',
  'Recibis una tabla con cifras ya calculadas y verificadas. Tu unico trabajo es redactarla en espanol claro.',
  'Reglas que no se negocian:',
  '- Usa solo numeros que aparezcan en la tabla, copiados exactamente como estan: mismos decimales, punto como separador decimal, sin separador de miles.',
  '- No calcules, no redondees, no sumes ni estimes ninguna cifra nueva. No uses las palabras aproximadamente, alrededor de, cerca de ni estimamos delante de un numero.',
  '- No inventes causas. Si proponés una hipotesis sobre por que paso algo, marcala con la palabra hipotesis y no la presentes como hecho.',
  '- No recomiendes cambios de puja ni de presupuesto. Si algo merece revision, decilo como pregunta para la persona de cuentas.',
  '- Si una campana figura como SIN DATOS SUFICIENTES, decilo asi; no interpretes sus variaciones.',
  'Estructura: un parrafo de resumen con los totales; una lista con cada anomalia (campana, metrica, variacion, gravedad) y una pregunta o hipotesis por anomalia; una frase final sobre las campanas sin datos, si las hay. Sin saludo ni despedida.',
].join('\n');

function construirPeticion(tabla, huerfanas, cfg) {
  let pedido = 'Tabla semanal:\n\n' + tabla + '\n\nRedacta el resumen siguiendo las reglas.';
  if (huerfanas && huerfanas.length) {
    pedido += '\n\nEl intento anterior fue rechazado porque estas cifras no estan en la tabla: ' + huerfanas.join(', ') + '. Volve a redactar usando solo cifras de la tabla.';
  }
  return {
    model: cfg.id,
    max_tokens: cfg.maxTokens,
    system: INSTRUCCIONES,
    messages: [{ role: 'user', content: pedido }],
  };
}

// POST https://api.anthropic.com/v1/messages (headers x-api-key, anthropic-version, content-type).
function llamarModelo(peticion, cfg) {
  const respuesta = UrlFetchApp.fetch('https://api.anthropic.com/v1/messages', {
    method: 'post',
    contentType: 'application/json',
    headers: { 'x-api-key': cfg.clave, 'anthropic-version': '2023-06-01' },
    payload: JSON.stringify(peticion),
    muteHttpExceptions: true,
  });
  const codigo = respuesta.getResponseCode();
  if (codigo !== 200) {
    Logger.log('Modelo: HTTP ' + codigo + ' · ' + respuesta.getContentText().slice(0, 500));
    return null;
  }
  const json = JSON.parse(respuesta.getContentText());
  if (json.stop_reason === 'refusal') {
    Logger.log('Modelo: la respuesta fue rechazada por el proveedor (stop_reason refusal).');
    return null;
  }
  const texto = (json.content || []).filter(function (b) { return b.type === 'text'; }).map(function (b) { return b.text; }).join('\n').trim();
  return { texto: texto, uso: json.usage || null, stop: json.stop_reason };
}

function redactarConCompuerta(tabla, cfg) {
  const permitidos = numerosDeTexto(tabla);
  let huerfanas = [];
  let uso = null;
  for (let intento = 1; intento <= 1 + cfg.reintentos; intento++) {
    const r = llamarModelo(construirPeticion(tabla, huerfanas, cfg), cfg);
    if (!r) return { texto: null, motivo: 'sin respuesta valida del modelo: se envia la tabla sin narrativa', intentos: intento, uso: uso };
    uso = r.uso;
    if (r.stop === 'max_tokens') Logger.log('Modelo: la respuesta se corto por max_tokens; se verifica igual.');
    const v = verificarCifras(r.texto, permitidos);
    if (v.ok) return { texto: r.texto, motivo: 'ok: ' + v.verificadas + ' cifras verificadas contra la tabla', intentos: intento, uso: uso };
    huerfanas = v.huerfanas.concat(v.muletillas);
    Logger.log('Compuerta: intento ' + intento + ' rechazado. Huerfanas: ' + huerfanas.join(', '));
  }
  return { texto: null, motivo: 'la compuerta rechazo la narrativa (' + huerfanas.join(', ') + '): se envia la tabla sin narrativa', intentos: 1 + cfg.reintentos, uso: uso };
}

// ---------------------------------------------------------------------------------------------
// 7. Entrega: email a la persona de cuentas (cola de aprobación) y, opcional, fila en una hoja
// ---------------------------------------------------------------------------------------------

function escaparHtml(s) {
  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
}

function entregar(resumen, tabla, compuerta) {
  const n = resumen.conteo.anomalias;
  const asunto = '[Pauta · ' + resumen.cliente + '] Semana ' + resumen.rango.actual.desdeIso + ' a ' + resumen.rango.actual.hastaIso +
    (n > 0 ? ' · ' + n + ' anomalia' + (n === 1 ? '' : 's') + (resumen.conteo.altas > 0 ? ' (' + resumen.conteo.altas + ' alta' + (resumen.conteo.altas === 1 ? '' : 's') + ')' : '') : ' · sin anomalias');

  const aviso = 'COLA DE APROBACION. Este resumen NO fue enviado al cliente y el script no cambio nada en la cuenta. ' +
    'Revisalo, editalo y enviaselo vos con tu nombre; si una anomalia requiere accion, la decidis en Google Ads, no desde el script.';
  const pie = 'Narrativa: ' + compuerta.motivo + ' · intentos: ' + compuerta.intentos +
    (compuerta.uso ? ' · tokens entrada ' + compuerta.uso.input_tokens + ', salida ' + compuerta.uso.output_tokens : '') +
    ' · modelo: ' + (CONFIG.modelo.clave ? CONFIG.modelo.id : 'no usado');

  const cuerpo = [aviso, '', compuerta.texto || '(Sin narrativa: leer la tabla.)', '', tabla, '', pie].join('\n');
  const html = '<p><strong>' + escaparHtml(aviso) + '</strong></p>' +
    (compuerta.texto ? '<div style="white-space:pre-wrap;font-family:sans-serif">' + escaparHtml(compuerta.texto) + '</div>' : '<p><em>Sin narrativa: leer la tabla.</em></p>') +
    '<pre style="font-size:12px;line-height:1.4">' + escaparHtml(tabla) + '</pre>' +
    '<p style="color:#666;font-size:12px">' + escaparHtml(pie) + '</p>';

  if (AdsApp.getExecutionInfo().isPreview()) {
    Logger.log('VISTA PREVIA: no se envia email ni se escribe la hoja. Asunto: ' + asunto + '\n\n' + cuerpo);
    return;
  }

  MailApp.sendEmail(CONFIG.destinatario, asunto, cuerpo, { htmlBody: html, name: 'Alertas de pauta · ' + resumen.cliente });
  Logger.log('Email enviado a ' + CONFIG.destinatario + ' · ' + asunto);

  if (CONFIG.hojaCola) {
    const hoja = SpreadsheetApp.openByUrl(CONFIG.hojaCola).getSheetByName(CONFIG.hojaColaPestana);
    if (!hoja) { Logger.log('Hoja de cola: no existe la pestana ' + CONFIG.hojaColaPestana); return; }
    hoja.appendRow([new Date(), resumen.cliente, resumen.rango.actual.desdeIso + ' a ' + resumen.rango.actual.hastaIso, n, resumen.conteo.altas, 'PENDIENTE', compuerta.motivo, compuerta.texto || '']);
  }
}

RESUMEN SEMANAL DE PAUTA · Acme (ejemplo)
Ventana actual: 2026-09-07 a 2026-09-13 (7 dias)
Base: 2026-08-10 a 2026-09-06 (28 dias, promediados a 7)
Moneda: MXN · Umbral de anomalia: 30% · Minimo de datos en la base: 100 clics, 50 de costo, 5 conversiones
Campanas analizadas: 4 · Con anomalias: 2 · Anomalias: 5 (altas: 4) · Sin datos suficientes: 1

TOTALES (actual | base semanal | variacion)
Costo: 1460.00 | 1267.50 | +15%
Conversiones: 41.0 | 58.0 | -29%
CPA: 35.61 | 21.85 | +63%
CTR: 3.32% | 2.07% | +61%

ANOMALIAS (campana · metrica · tipo · variacion · gravedad)
- Search · Genéricas · costo · sube · +40% · media
- Search · Genéricas · conversiones · baja · -59% · alta
- Search · Genéricas · cpa · sube · +242% · alta
- Display · Remarketing · costo · sin_gasto · -100% · alta
- Display · Remarketing · conversiones · sin_conversiones · -100% · alta

POR CAMPANA (costo actual | base; conversiones actual | base; CPA actual | base; CTR actual | base)
- Search · Genéricas: costo 980.00 | 700.00; conv 9.0 | 22.0; CPA 108.89 | 31.82; CTR 2.33% | 2.96%
- Display · Remarketing: costo 0.00 | 160.00; conv 0.0 | 6.0; CPA sin dato | 26.67; CTR sin dato | 0.90%
- Search · Marca: costo 420.00 | 400.00; conv 31.0 | 30.0; CPA 13.55 | 13.33; CTR 6.22% | 5.85%
- Search · Prueba nueva [SIN DATOS SUFICIENTES: clics, costo]: costo 60.00 | 7.50; conv 1.0 | 0.0; CPA 60.00 | sin dato; CTR 4.44% | 4.40%

// Cuenta de administrador: reemplazá main() por estas tres funciones y pegá el resto del script igual.
// Hasta 50 cuentas por corrida con executeInParallel (límite de la plataforma). Con callback, el
// script puede correr hasta 60 minutos en vez de 30.
const CUENTAS = {
  '123-456-7890': { cliente: 'Acme', destinatario: 'ana@tuagencia.com' },
  '234-567-8901': { cliente: 'Globex', destinatario: 'luis@tuagencia.com' },
};

function main() {
  AdsManagerApp.accounts().withIds(Object.keys(CUENTAS)).executeInParallel('procesarCuenta', 'alTerminar');
}

// Corre dentro de cada cuenta cliente, con su propia cuota de 30 minutos.
function procesarCuenta() {
  const cuenta = AdsApp.currentAccount();
  const datos = CUENTAS[cuenta.getCustomerId()];
  CONFIG.cliente = datos.cliente;
  CONFIG.destinatario = datos.destinatario;

  const rango = rangos(new Date(), cuenta.getTimeZone(), CONFIG.ventanas);
  const resumen = armarResumen(leerCampanas(rango), rango, cuenta.getCurrencyCode(), CONFIG);
  const tabla = tablaTexto(resumen);
  let compuerta = { texto: null, motivo: 'sin clave: se envía la tabla sin narrativa', intentos: 0, uso: null };
  if (CONFIG.modelo.clave) compuerta = redactarConCompuerta(tabla, CONFIG.modelo);
  entregar(resumen, tabla, compuerta);

  return JSON.stringify({ cliente: datos.cliente, anomalias: resumen.conteo.anomalias, altas: resumen.conteo.altas, narrativa: compuerta.motivo });
}

// Corre una sola vez, en la cuenta de administrador, cuando terminaron todas.
function alTerminar(resultados) {
  for (const r of resultados) {
    if (r.getError()) Logger.log(r.getCustomerId() + ' · ERROR: ' + r.getError());
    else Logger.log(r.getCustomerId() + ' · ' + r.getReturnValue());
  }
}