Cómo Medir tu Visibilidad en Búsqueda con IA en 2026: Crawlers, GA4 y Logs

1. El Problema: tu Dashboard Mide las Cosas Equivocadas

La búsqueda con IA rompe la medición en tres lugares, y cada uno falla en una dirección distinta. Los bots que ejecutan tu JavaScript inflan Direct con sesiones falsas. Los bots que solo piden HTML nunca llegan a GA4, así que no los ves. Y las personas reales que hacen clic en una respuesta dentro de una app de IA muchas veces llegan sin referrer, así que también se esconden en Direct. Un solo dashboard no desenreda eso: necesitás tres fuentes, analytics, logs del servidor y robots.txt.

La comparación que importa: unas 17 sesiones humanas de búsqueda clásica por cada una de un asistente de IA, acá. Con números tan chicos no leería una tendencia, pero tampoco confiaría en un reporte que muestre el tráfico de IA en cero, ni en uno que muestre Direct como el 91% de mi audiencia.

2. Conceptos Mínimos Antes de Tocar Código

Seis ideas cubren casi todo lo que necesitás. Con esto claro, el robots.txt, el canal de GA4 y el script de logs se leen como castellano simple.

3. Paso 1 — Inventario de Bots (Desde la Documentación de los Proveedores)

Arrancá por lo que los proveedores publican de sí mismos, no por blogs: los nombres cambian y algunas guías todavía listan agentes que el proveedor ya no documenta (el artículo de ayuda actual de Anthropic lista ClaudeBot, Claude-User y Claude-SearchBot y no menciona anthropic-ai). Todo lo de abajo se revisó contra la página de cada proveedor en octubre de 2026.

4. Paso 2 — robots.txt, un Grupo por Trabajo

En robots.txt la taxonomía se vuelve política: permitís los bots que recuperan tu contenido para respuestas, decidís el entrenamiento por separado y mantenés un grupo comodín. Varias líneas User-agent pueden ir encima de un mismo set de reglas, como muestran los docs de Google.

public/robots.txt — un grupo por trabajo (el Pages Router lo sirve como archivo estático)

# 1) Search and retrieval bots: they feed answers, allow them
User-agent: OAI-SearchBot
User-agent: Claude-SearchBot
User-agent: PerplexityBot
User-agent: meta-webindexer
User-agent: Applebot
Allow: /
Disallow: /admin
Disallow: /api/

# 2) User-triggered fetchers: a person asked about one of your pages.
#    Some vendors say these may ignore robots.txt anyway.
User-agent: ChatGPT-User
User-agent: Claude-User
User-agent: Perplexity-User
User-agent: meta-externalfetcher
Allow: /
Disallow: /admin
Disallow: /api/

# 3) Training / model improvement: YOUR decision (example: opt out)
User-agent: GPTBot
User-agent: ClaudeBot
User-agent: Google-Extended
User-agent: Applebot-Extended
User-agent: meta-externalagent
Disallow: /

# 4) Everyone else (Googlebot, Bingbot, ...)
User-agent: *
Allow: /
Disallow: /admin
Disallow: /api/

Sitemap: https://www.diego-rodriguez.work/sitemap.xml

Si generás el archivo con next-sitemap, los mismos grupos van en robotsTxtOptions.policies. Hay una sutileza que muerde: los docs de Google dicen que un user agent coincide solo con el primer grupo más específico, así que un grupo de un bot no hereda los Disallow del grupo *. Por eso cada grupo de arriba repite /admin y /api/.

5. Paso 3 — GA4: el Canal AI Assistant y una Regex de Respaldo

Algunas guías viejas todavía te dicen que GA4 no tiene canal de IA y que tenés que armar uno. La documentación de Google dice que sí: se agregó un canal AI Assistant al grupo de canales predeterminado el 13 de mayo de 2026 (notas de versión de Analytics). La regla es que el medium coincida exactamente con ai-assistant, y GA4 asigna ese medium (y la campaña (ai-assistant)) cuando el referrer coincide con una lista de asistentes de IA. Google nombra ChatGPT, Gemini, DeepSeek, Copilot y Grok como ejemplos, publica la lista completa solo como hoja de cálculo y deja AI Overviews y AI Mode en Organic Search.

Dos límites importan. Primero, solo funciona cuando GA4 vio un referrer reconocido: las sesiones sin referrer ni tag siguen cayendo en Direct, y notas independientes también reportan sesiones con tag pero sin medium que terminan en Unassigned. Segundo, la lista es de Google, no tuya. En esta propiedad perplexity.ai ya caía en AI Assistant, mientras que una nota independiente reporta que Perplexity queda en Referral, así que verificalo con tus datos. Un grupo de canales personalizado te da una lista que controlás vos, al lado de la nativa.

GA4 Admin → Data display → Channel groups → Create new channel group

Channel name:  AI assistants (custom)
Condition:     Source   matches regex
Pattern:       ^(.*\.)?(chatgpt\.com|chat\.openai\.com|perplexity\.ai|claude\.ai|gemini\.google\.com|copilot\.com|copilot\.microsoft\.com|deepseek\.com|grok\.com|you\.com)$
Order:         drag it ABOVE Referral (and above Organic Search if AI sources show up there)

scripts/ga4-channels.js — canales con engagement, Direct con pinta de bot marcado

// npm i @google-analytics/data
// GOOGLE_APPLICATION_CREDENTIALS=key.json GA_PROPERTY_ID=123456789 node scripts/ga4-channels.js
const { BetaAnalyticsDataClient } = require("@google-analytics/data");

const client = new BetaAnalyticsDataClient();
const HUMAN = ["Organic Search", "AI Assistant", "Referral", "Organic Social"];

async function main() {
  const [res] = await client.runReport({
    property: "properties/" + process.env.GA_PROPERTY_ID,
    dateRanges: [{ startDate: "90daysAgo", endDate: "today" }],
    dimensions: [{ name: "sessionDefaultChannelGroup" }, { name: "sessionSource" }],
    metrics: [{ name: "sessions" }, { name: "userEngagementDuration" }],
    limit: 500,
  });

  const by = {};
  for (const row of res.rows || []) {
    const [channel, source] = row.dimensionValues.map((d) => d.value);
    const sessions = Number(row.metricValues[0].value);
    const engaged = Number(row.metricValues[1].value); // seconds, summed
    const c = (by[channel] ||= { sessions: 0, engaged: 0, sources: {} });
    c.sessions += sessions;
    c.engaged += engaged;
    c.sources[source] = (c.sources[source] || 0) + sessions;
  }

  const total = Object.values(by).reduce((n, c) => n + c.sessions, 0);
  const sorted = Object.entries(by).sort((a, b) => b[1].sessions - a[1].sessions);
  for (const [name, c] of sorted) {
    const avg = c.engaged / Math.max(c.sessions, 1);
    const top = Object.entries(c.sources).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([s, n]) => s + " " + n).join(", ");
    // heuristic, not a verdict: lots of sessions with ~0 s engagement
    const verdict = HUMAN.includes(name) ? "human" : avg < 1 && c.sessions > 20 ? "BOT-LIKE" : "check";
    console.log([name.padEnd(18), String(c.sessions).padStart(6), ((100 * c.sessions) / total).toFixed(0) + "%", avg.toFixed(1) + "s", verdict, top].join("  "));
  }
}
main().catch((e) => { console.error(e.message); process.exit(1); });

Corrélo y leé la columna de engagement al lado de la cantidad de sesiones. Un canal con cientos de sesiones y menos de un segundo de engagement no es una audiencia; ese es el número que hay que sacar antes de que alguien presente un porcentaje de participación de IA.

6. Paso 4 — Logs: Contá los Bots que GA4 No Ve

Los logs de tu servidor o CDN registran cada request, incluso de clientes que nunca ejecutan JavaScript. Dos formas baratas de armar un reporte de bots: parsear el access log que ya tenés, o emitir una línea JSON por cada hit de bot de IA desde un middleware.

scripts/ai-bots-report.js — hits por bot desde un log en formato combined

// node scripts/ai-bots-report.js /var/log/nginx/access.log   (Node 16+)
const fs = require("node:fs");
const readline = require("node:readline");

// user-agent token -> job
const BOTS = {
  "OAI-SearchBot": "search", GPTBot: "training", "ChatGPT-User": "user fetch",
  "Claude-SearchBot": "search", ClaudeBot: "training", "Claude-User": "user fetch",
  PerplexityBot: "search", "Perplexity-User": "user fetch",
  Applebot: "search (+training)", "meta-webindexer": "search",
  "meta-externalagent": "training", "meta-externalfetcher": "user fetch",
};

// combined log format: ip - - [time] "METHOD path HTTP/x" status bytes "referer" "user-agent"
const LINE = /^(\S+) \S+ \S+ \[[^\]]+\] "\S+ (\S+)[^"]*" (\d{3}) \S+ "[^"]*" "([^"]*)"/;

async function main(file) {
  const stats = {};
  const rl = readline.createInterface({ input: fs.createReadStream(file) });
  for await (const line of rl) {
    const m = LINE.exec(line);
    if (!m) continue;
    const [, ip, path, status, ua] = m;
    const bot = Object.keys(BOTS).find((n) => ua.toLowerCase().includes(n.toLowerCase()));
    if (!bot) continue;
    const s = (stats[bot] ||= { job: BOTS[bot], hits: 0, ok: 0, robots: 0, ips: new Set(), paths: {} });
    s.hits++;
    if (status[0] === "2") s.ok++;
    if (path === "/robots.txt") s.robots++;
    s.ips.add(ip);
    s.paths[path] = (s.paths[path] || 0) + 1;
  }
  const top = (paths) => Object.entries(paths).sort((a, b) => b[1] - a[1])[0][0];
  console.table(
    Object.entries(stats)
      .sort((a, b) => b[1].hits - a[1].hits)
      .map(([bot, s]) => ({ bot, job: s.job, hits: s.hits, "2xx %": Math.round((100 * s.ok) / s.hits), robots: s.robots, ips: s.ips.size, top: top(s.paths) }))
  );
}
main(process.argv[2]).catch((e) => { console.error(e.message); process.exit(1); });

En un hosting sin access logs crudos, el middleware te da la misma señal. Esta es sintaxis del Pages Router de Next.js 13; Next.js 16 renombró la convención a proxy.js, así que ajustalo si actualizás. Corre en cada request que matchea, así que mantenelo barato: es una herramienta de medición, no un firewall.

middleware.js — una línea JSON por request de bot de IA

// middleware.js  (project root, next to pages/)  ·  Next.js 13 Pages Router
import { NextResponse } from "next/server";

const AI_BOTS =
  /(OAI-SearchBot|GPTBot|ChatGPT-User|Claude-SearchBot|ClaudeBot|Claude-User|PerplexityBot|Perplexity-User|Applebot|meta-webindexer|meta-externalagent|meta-externalfetcher|Google-Agent)/i;

export function middleware(request) {
  const ua = request.headers.get("user-agent") || "";
  const hit = ua.match(AI_BOTS);
  if (hit) {
    // one JSON line per hit: grep it, or ship it with your host's log drain
    const ip = request.headers.get("x-forwarded-for");
    console.log(JSON.stringify({ type: "ai-bot", bot: hit[1], path: request.nextUrl.pathname, ip, t: new Date().toISOString() }));
  }
  return NextResponse.next();
}

// run on pages and robots.txt, skip build assets
export const config = {
  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
};

7. Paso 5 — Verificá que el Bot Sea Real

Un string de user agent es una afirmación que cualquier script puede hacer. Antes de que un número entre a un reporte, revisá la IP de origen: OpenAI, Anthropic, Perplexity, Google y Apple publican rangos de IP como listas JSON de prefijos CIDR, y Google y Apple documentan también DNS inverso (Google: lookup inverso, hostname bajo googlebot.com, google.com o googleusercontent.com, y después lookup directo que vuelva a la misma IP).

scripts/verify-bot-ip.js — rangos publicados más DNS inverso y directo

// node scripts/verify-bot-ip.js 203.0.113.7 GPTBot   (Node 18+: global fetch)
const { BlockList, isIP } = require("node:net");
const dns = require("node:dns").promises;

// IP range files published by each vendor: { prefixes: [{ ipv4Prefix | ipv6Prefix }] }
const RANGES = {
  GPTBot: "https://openai.com/gptbot.json",
  "OAI-SearchBot": "https://openai.com/searchbot.json",
  "ChatGPT-User": "https://openai.com/chatgpt-user.json",
  ClaudeBot: "https://claude.com/crawling/bots.json", // one list for Anthropic's bots
  PerplexityBot: "https://www.perplexity.com/perplexitybot.json",
  Googlebot: "https://developers.google.com/static/crawling/ipranges/common-crawlers.json",
  Applebot: "https://search.developer.apple.com/applebot.json",
};
// Google and Apple also document reverse DNS (hostname suffixes)
const RDNS = {
  Googlebot: [".googlebot.com", ".google.com", ".googleusercontent.com"],
  Applebot: [".applebot.apple.com"],
};

async function inRanges(bot, ip) {
  const { prefixes } = await (await fetch(RANGES[bot])).json();
  const list = new BlockList();
  for (const p of prefixes) {
    const [addr, len] = (p.ipv4Prefix || p.ipv6Prefix).split("/");
    list.addSubnet(addr, Number(len), p.ipv4Prefix ? "ipv4" : "ipv6");
  }
  return list.check(ip, isIP(ip) === 6 ? "ipv6" : "ipv4");
}

// reverse DNS -> hostname ends with a documented suffix -> forward DNS returns the same IP
async function rdnsOk(bot, ip) {
  try {
    for (const host of await dns.reverse(ip)) {
      if (!RDNS[bot].some((s) => host.endsWith(s))) continue;
      if ((await dns.lookup(host, { all: true })).some((a) => a.address === ip)) return true;
    }
  } catch (e) {
    // no PTR record: not verified
  }
  return false;
}

(async () => {
  const [ip, bot] = process.argv.slice(2);
  if (!RANGES[bot]) throw new Error("unknown bot: " + bot);
  console.log({ bot, ip, inRanges: await inRanges(bot, ip), rdnsOk: RDNS[bot] ? await rdnsOk(bot, ip) : "n/a" });
})();

Cacheá los JSON, cambian. Anthropic advierte que bloquear por IP puede impedir que su crawler lea tu robots.txt y que puede no dar un opt-out confiable, así que usá los rangos para verificar lo que ya registraste y robots.txt para la política. Para proveedores cuyas páginas leí sin lista de IPs (Meta, por ejemplo), tratá los conteos solo por user agent como no verificados.

8. Paso 6 — Datos Estructurados y los Reportes de los Proveedores

En el Pages Router, JSON-LD es un tag script común con type application/ld+json dentro de next/head. Los docs de Next.js recomiendan un script nativo en lugar de next/script y advierten que JSON.stringify no sanitiza strings, así que reemplazá < por su escape unicode. Dale una key al tag para que no se duplique entre renders.

components/JsonLd.js — Pages Router

// components/JsonLd.js  (Pages Router: render inside next/head)
import Head from "next/head";

export default function JsonLd({ id, data }) {
  return (
    <Head>
      <script
        key={id}
        type="application/ld+json"
        dangerouslySetInnerHTML={{
          // JSON.stringify does not sanitize: escape "<" so a value can never close the tag
          __html: JSON.stringify(data).replace(/</g, "\\u003c"),
        }}
      />
    </Head>
  );
}

// pages/blog/my-post.js
<JsonLd
  id="article-ld"
  data={{
    "@context": "https://schema.org",
    "@type": "BlogPosting",
    headline: "Measuring AI search visibility",
    datePublished: "2026-10-14",
    dateModified: "2026-10-14",
    author: { "@type": "Person", name: "Diego Rodriguez", url: "https://www.diego-rodriguez.work" },
  }}
/>

9. Una Rutina de Medición que Aguanta

La medición se pudre cuando es de una sola vez. Esta es la cadencia que correría en cualquier sitio que se preocupe por la visibilidad en IA, en el orden en que los datos se vuelven más baratos de leer:

10. Errores Comunes (Todos Arreglables en una Tarde)

Casi cada número engañoso de tráfico de IA que vi cae en uno de estos baldes. La columna izquierda es lo que hacen los reportes confiables; la derecha es lo que produce una slide equivocada pero muy segura de sí misma.

Conclusión

Ahora tenés tres instrumentos: un inventario de bots sacado de la documentación de los proveedores, un robots.txt que codifica una política por trabajo y dos reportes (GA4 por canal y engagement, logs por bot) que podés verificar contra rangos de IP publicados. Ninguno te dice solo ’qué tan visible soy en las respuestas de IA’. Juntos te dicen qué podés afirmar y qué no.

Esta semana: corré los dos scripts una vez, anotá tres números (sesiones humanas, sesiones de AI Assistant, hits verificados de bots de IA) y dejá de reportar la línea cruda de Direct. Después usá los posts de GEO de abajo para decidir qué cambiar, y volvé en un mes para ver si los números se movieron.

Fuentes

• OpenAI — Resumen de los crawlers de OpenAI (OAI-SearchBot, GPTBot, ChatGPT-User)
• Anthropic — ¿Anthropic rastrea la web y cómo pueden bloquear el crawler los dueños de sitios?
• Perplexity — PerplexityBot y Perplexity-User
• Google — Crawlers comunes (Googlebot, Google-Extended)
• Google — Fetchers disparados por el usuario
• Google — Verificar requests de crawlers y fetchers de Google
• Google Search — Funciones de IA y tu sitio web
• Google Search — Crear y enviar un archivo robots.txt
• Apple — Acerca de Applebot (Applebot-Extended, DNS inverso, lista de IPs)
• Meta — Web crawlers (meta-webindexer, meta-externalagent, meta-externalfetcher)
• Ayuda de Google Analytics — Grupo de canales predeterminado (AI Assistant)
• Ayuda de Google Analytics — Grupos de canales personalizados
• Ayuda de Google Analytics — Acerca de las expresiones regulares
• Ayuda de Google Analytics — Exclusión de tráfico de bots conocidos
• Google Analytics — Notas de versión (canal AI Assistant, 13 de mayo de 2026)
• Next.js — Cómo implementar JSON-LD
• Next.js — proxy.js (antes middleware.js) y matcher
• Bing Webmaster Blog — Presentación de AI Performance (vista previa pública)
• Clickport — Por qué el tráfico de ChatGPT aparece como Direct en GA4 (datos de proveedor)
• Search Engine Land — Bing/Copilot de Microsoft usan schema para sus LLMs (nota secundaria)