Shopify no te da archivos de registro. Aqui tienes una guia tecnica completa para obtenerlos con Cloudflare (o cualquier CDN de borde).

Un gran punto ciego en el comercio electronico acaba de resolverse

Desde el dia en que Shopify se lanzo, la plataforma ha mantenido los registros sin procesar del servidor completamente fuera del alcance de los propietarios de tiendas. Obtienes embudos de conversion e informes de ventas. Lo que no obtienes es lo unico que realmente te dice que esta llegando a tu servidor: el registro de solicitudes HTTP.

Durante anos, esto fue una molestia menor. A quien le importan los registros sin procesar cuando tienes vistas de pagina y tasas de conversion? Google Analytics rastrea a tus humanos. Tu plataforma de publicidad rastrea tus campanas. La vida es buena.

Entonces llego la IA.

ChatGPT, Claude, Perplexity, Google AI Overviews, Microsoft Copilot - todos estan enviando bots a tu tienda ahora mismo. Algunos estan rastreando tus paginas para construir datos de entrenamiento. Otros estan obteniendo el contenido de tus productos en tiempo real para responder las preguntas de un cliente. Y lo peor de todo: las herramientas de analitica tradicionales como Google Analytics no pueden ver nada de esto. Dependen de JavaScript del lado del cliente que los bots nunca ejecutan. La mayoria de la interaccion de la IA con tu tienda es invisible para ti.

Este es el nuevo punto ciego del comercio electronico. Los bots de IA no ejecutan tus scripts de seguimiento. No aceptan cookies. No aparecen en tus informes de GA4. Pero absolutamente estan leyendo las paginas de tus productos, incorporando tus descripciones en respuestas generadas por IA y determinando si los clientes alguna vez descubren tu marca.

Estan surgiendo nuevas herramientas enfocadas en “analitica de agentes” para ayudar a los propietarios de sitios a comprender la actividad de rastreadores de IA y las referencias generadas por IA a traves de seguimiento del lado del servidor, clasificacion de bots y verificacion de IP. La industria reconoce que el antiguo modelo de analitica del lado del cliente esta fundamentalmente roto para la era del descubrimiento de contenido impulsado por IA. Es por eso que construimos el Panel de Visibilidad de IA de WISLR - para dar a las marcas una imagen clara de como las plataformas de IA estan interactuando con su contenido, desde tasas de rastreo hasta solicitudes de obtencion y trafico de referencia impulsado por IA.

Pero si estas en Shopify, tienes un problema unico: no controlas el servidor. No puedes instalar seguimiento del lado del servidor directamente. No puedes consultar tus registros de acceso. No puedes buscar GPTBot con grep. La infraestructura de Shopify es una caja negra, y no han mostrado ninguna urgencia por abrirla.

Se acabo. Aqui te mostramos como recuperar tus registros.

Esta guia te lleva paso a paso a construir tu propio pipeline completo de registro de solicitudes para una tienda Shopify usando Cloudflare. Cada solicitud HTTP. Datos geograficos completos. Metricas de rendimiento. Y lo mas importante, deteccion y clasificacion completa de bots, para que finalmente puedas ver exactamente que sistemas de IA estan visitando tu tienda, con que frecuencia y que paginas les interesan.

Como funciona el registro de solicitudes de Cloudflare para Shopify?

 Visitante solicita tu tienda Shopify
         │
         ▼
 Cloudflare CDN (tu dominio proxied a traves de Cloudflare)
         │
         ▼
 Cloudflare Worker (se ejecuta en cada solicitud)
    ├──→ Pasa la solicitud a Shopify origin (el visitante recibe la respuesta normal)
    └──→ Envia un registro JSON via POST a tu receptor de registros (no bloqueante, via ctx.waitUntil)
              │
              ▼
         Cloudflare Tunnel
         (CNAME en tu dominio → tunnel → localhost en tu servidor)
              │
              ▼
         Receptor HTTP Node.js (localhost:9090)
              │
              ▼
         Archivos de registro JSON escritos en disco

No se exponen puertos publicamente. El Cloudflare Tunnel maneja el transporte seguro desde el borde de Cloudflare hasta tu servidor a traves de una conexion solo de salida.

Que necesitas para configurar el registro de solicitudes de Shopify?

• Una tienda Shopify con un dominio personalizado proxied a traves de Cloudflare (nube naranja habilitada)
• Un servidor para recibir registros
• Node.js instalado en el servidor
• Una cuenta de Cloudflare con Workers habilitados
• Wrangler CLI instalado (npm install -g wrangler)
• Cloudflared instalado en el servidor

Paso 1: Crear el Cloudflare Worker

El Worker intercepta cada solicitud en tu dominio, la envia a Shopify y transmite asincronamente una entrada de registro a tu receptor.

1a. Codigo fuente del Worker (cloudflare-worker.js)

/**
 * Shopify Request Logger
 *
 * Cloudflare Worker that:
 * 1. Logs ALL requests to a self-hosted log receiver (via Cloudflare Tunnel)
 * 2. Optionally logs detailed bot request data to a database
 */

// ============================================
// CONFIG - update these for your setup
// ============================================
const INGEST_URL = 'https://log-collector.yourdomain.com/collect';  // Your tunnel hostname
const INGEST_API_KEY = process.env.INGEST_API_KEY || '';          // Set as Worker secret

// ============================================
// BOT DETECTION PATTERNS
// ============================================
const BOT_PATTERNS = {
  // AI realtime fetchers (user-triggered queries)
  'ChatGPT-User':    { pattern: /ChatGPT-User/i,    type: 'realtime' },
  'Perplexity-User': { pattern: /Perplexity-User/i,  type: 'realtime' },
  // Add your own patterns here for other AI bots

  // Search engine crawlers
  'Googlebot':       { pattern: /Googlebot/i,        type: 'crawler' },
  'Bingbot':         { pattern: /bingbot/i,          type: 'crawler' },

  // Social link preview bots
  'FacebookBot':     { pattern: /facebookexternalhit/i, type: 'preview' },
  'LinkedInBot':     { pattern: /LinkedInBot/i,      type: 'preview' },
};

function identifyBot(userAgent) {
  if (!userAgent) return { name: 'unknown', type: 'unknown' };
  for (const [name, config] of Object.entries(BOT_PATTERNS)) {
    if (config.pattern.test(userAgent)) return { name, type: config.type };
  }
  return { name: 'other', type: 'unknown' };
}

function isKnownBot(userAgent) {
  if (!userAgent) return false;
  return Object.values(BOT_PATTERNS).some(config => config.pattern.test(userAgent));
}

async function logToReceiver(request, env, perfData = {}) {
  const url = new URL(request.url);
  const cf = request.cf || {};
  const bot = identifyBot(request.headers.get('user-agent') || '');

  const logEntry = {
    // Request basics
    timestamp:        new Date().toISOString(),
    method:           request.method,
    url:              request.url,
    path:             url.pathname,
    host:             url.hostname,
    userAgent:        request.headers.get('user-agent') || '',
    ip:               request.headers.get('cf-connecting-ip') || '',
    referer:          request.headers.get('referer') || '',
    cfRay:            request.headers.get('cf-ray') || '',

    // Bot classification
    botName:          bot.name,
    botType:          bot.type,

    // Cloudflare geo data
    country:          cf.country || '',
    region:           cf.region || '',
    city:             cf.city || '',
    postalCode:       cf.postalCode || '',
    latitude:         cf.latitude || '',
    longitude:        cf.longitude || '',
    timezone:         cf.timezone || '',
    continent:        cf.continent || '',

    // Network info
    asn:              cf.asn || '',
    asOrganization:   cf.asOrganization || '',
    colo:             cf.colo || '',
    httpProtocol:     cf.httpProtocol || '',
    tlsVersion:       cf.tlsVersion || '',

    // Client hints (helps detect headless browsers)
    secChUa:          request.headers.get('sec-ch-ua') || '',
    secChUaMobile:    request.headers.get('sec-ch-ua-mobile') || '',
    secChUaPlatform:  request.headers.get('sec-ch-ua-platform') || '',

    // Fetch metadata (helps detect programmatic requests)
    secFetchDest:     request.headers.get('sec-fetch-dest') || '',
    secFetchMode:     request.headers.get('sec-fetch-mode') || '',
    secFetchSite:     request.headers.get('sec-fetch-site') || '',

    // Performance metrics
    edgeStartTimestamp:       perfData.startTime || '',
    edgeEndTimestamp:         perfData.endTime || '',
    edgeTimeToFirstByteMs:   perfData.ttfbMs ?? '',
    clientTcpRttMs:          cf.clientTcpRtt ?? '',
    cacheCacheStatus:        perfData.cacheStatus || '',
    originResponseStatus:    perfData.responseStatus ?? '',
  };

  try {
    await fetch(INGEST_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': env.INGEST_API_KEY,
      },
      body: JSON.stringify({ logs: [logEntry] }),
    });
  } catch (e) {
    console.error(`Log ingest failed: ${e.message}`);
  }
}

export default {
  async fetch(request, env, ctx) {
    const startTime = Date.now();
    const url = new URL(request.url);

    // Avoid infinite loop - skip logging for your ingest hostname
    if (url.hostname === 'log-collector.yourdomain.com') {
      return fetch(request);
    }

    // Fetch the origin response (Shopify)
    const response = await fetch(request);
    const endTime = Date.now();

    // Ship log entry asynchronously (does not delay the response)
    ctx.waitUntil(logToReceiver(request, env, {
      startTime,
      endTime,
      ttfbMs: endTime - startTime,
      cacheStatus: response.headers.get('cf-cache-status') || '',
      responseStatus: response.status,
    }));

    return response;
  }
};

1b. Configuracion de Wrangler (wrangler.toml)

name = "shopify-request-logger"
main = "cloudflare-worker.js"
compatibility_date = "2024-01-01"

routes = [
  { pattern = "www.yourdomain.com/*", zone_name = "yourdomain.com" }
]

Reemplaza www.yourdomain.com con el dominio personalizado de tu tienda Shopify.

1c. Configurar secretos del Worker

wrangler secret put INGEST_API_KEY
# Paste your generated API key when prompted

1d. Desplegar

npx wrangler deploy

Paso 2: Configurar el receptor de registros en tu servidor

Un servidor HTTP minimo en Node.js que acepta lotes de registros y los escribe en disco.

2a. Script del receptor (receive-logs.js)

const http = require('http');
const fs = require('fs');
const path = require('path');

const PORT = 9090;
const API_KEY = process.env.LOG_API_KEY;
const LOG_DIR = '/var/log/cdn-requests';  // Choose your log directory

if (!API_KEY) {
  console.error('LOG_API_KEY environment variable is required');
  process.exit(1);
}

// Ensure log directory exists
fs.mkdirSync(LOG_DIR, { recursive: true });

const server = http.createServer((req, res) => {
  // Health check
  if (req.method === 'GET' && req.url === '/status') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok' }));
    return;
  }

  // Log ingest endpoint
  if (req.method === 'POST' && req.url === '/collect') {
    const apiKey = req.headers['x-api-key'];
    if (apiKey !== API_KEY) {
      res.writeHead(401, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ error: 'unauthorized' }));
      return;
    }

    let body = '';
    let size = 0;
    const MAX_BODY = 10 * 1024 * 1024; // 10MB limit

    req.on('data', chunk => {
      size += chunk.length;
      if (size > MAX_BODY) {
        res.writeHead(413, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'payload too large' }));
        req.destroy();
        return;
      }
      body += chunk;
    });

    req.on('end', () => {
      try {
        JSON.parse(body); // Validate JSON
      } catch (e) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'invalid JSON' }));
        return;
      }

      const filename = `logs-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
      const filepath = path.join(LOG_DIR, filename);

      fs.writeFile(filepath, body, err => {
        if (err) {
          console.error(`Write failed: ${err.message}`);
          res.writeHead(500, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ error: 'write failed' }));
          return;
        }
        console.log(`Wrote ${filename} (${size} bytes)`);
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ ok: true }));
      });
    });
  } else {
    res.writeHead(404, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ error: 'not found' }));
  }
});

server.listen(PORT, '127.0.0.1', () => {
  console.log(`Log receiver listening on 127.0.0.1:${PORT}`);
});

Puntos clave:

• Se enlaza solo a 127.0.0.1 - no esta expuesto a internet
• Autentica las solicitudes con un encabezado X-API-Key
• Escribe cada lote de registros como un archivo JSON con marca de tiempo
• Limite de 10MB por solicitud

2b. Servicio systemd

Crea /etc/systemd/system/log-receiver.service:

[Unit]
Description=Shopify request log receiver
After=network.target

[Service]
Type=simple
Environment=LOG_API_KEY=<your-generated-api-key>
ExecStart=/usr/bin/node /opt/log-receiver/receive-logs.js
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

Habilitar e iniciar:

systemctl daemon-reload
systemctl enable --now log-receiver

Paso 3: Configurar el Cloudflare Tunnel

El tunnel crea una conexion segura desde el borde de Cloudflare hasta tu servidor - sin puertos abiertos, sin reglas de firewall necesarias.

3a. Instalar cloudflared

# Debian/Ubuntu
curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb \
  -o /tmp/cloudflared.deb
dpkg -i /tmp/cloudflared.deb

3b. Autenticarse

cloudflared tunnel login
# Opens a browser (or gives you a URL) to authorize with your Cloudflare account

Esto guarda un cert.pem en ~/.cloudflared/.

3c. Crear el Tunnel

cloudflared tunnel create shopify-log-collector

Esto genera un Tunnel ID (un UUID) y crea un archivo JSON de credenciales en ~/.cloudflared/.

3d. Configurar el Tunnel

Crea ~/.cloudflared/config.yml:

tunnel: <YOUR-TUNNEL-ID>
credentials-file: /root/.cloudflared/<YOUR-TUNNEL-ID>.json

ingress:
  - hostname: log-collector.yourdomain.com
    service: http://localhost:9090
  - service: http_status:404

• hostname: El subdominio al que tu Worker enviara los registros via POST
• service: Enruta hacia tu receptor Node.js en localhost:9090
• Regla catch-all: Devuelve 404 para cualquier otro hostname (requerido por cloudflared)

3e. Crear el registro DNS

cloudflared tunnel route dns shopify-log-collector log-collector.yourdomain.com

Esto crea un registro CNAME en tu DNS de Cloudflare:

log-collector.yourdomain.com  →  <TUNNEL-ID>.cfargotunnel.com

El registro esta proxied a traves de Cloudflare (nube naranja) - el ID del tunnel en el CNAME no tiene significado publico.

3f. Instalar como servicio del sistema

cloudflared service install
systemctl enable --now cloudflared

Esto copia tu configuracion a /etc/cloudflared/config.yml y crea una unidad systemd.

Verificar el Tunnel

systemctl status cloudflared
# Should show: active (running)

curl https://log-collector.yourdomain.com/status
# Should return: {"status":"ok"}

Paso 4: Generar tu clave API

Genera una clave API aleatoria compartida entre el Worker y el receptor:

openssl rand -hex 32

Establece este valor:

1. Como un secreto del Worker via wrangler secret put INGEST_API_KEY
2. En la linea Environment de systemd del receptor (LOG_API_KEY=…)

Paso 5: Verificar de extremo a extremo

1. Visita tu tienda Shopify en un navegador
2. Revisa los registros del receptor:

journalctl -u log-receiver -f
# Should show: Wrote logs-1234567890-abc123.json (1234 bytes)

3. Inspecciona un archivo de registro:

cat /var/log/cdn-requests/logs-*.json | head -1 | python3 -m json.tool

Deberias ver una entrada de registro completa con detalles de la solicitud, datos geograficos y metricas de rendimiento.

Ejemplo de entrada de registro

{
  "logs": [{
    "timestamp": "2026-03-04T15:19:55.584Z",
    "method": "GET",
    "url": "https://www.yourdomain.com/products/example",
    "path": "/products/example",
    "host": "www.yourdomain.com",
    "userAgent": "Mozilla/5.0 ...",
    "ip": "198.51.100.23",
    "country": "US",
    "city": "Seattle",
    "asn": 16509,
    "asOrganization": "Amazon.com",
    "colo": "SEA",
    "edgeTimeToFirstByteMs": 109,
    "originResponseStatus": 200,
    "cacheCacheStatus": "HIT",
    "botName": "other",
    "botType": "unknown"
  }]
}

Como funciona el pipeline completo de registro de Shopify?

Flujo de datos

1. Visitor hits https://www.yourdomain.com/products/something
2. Cloudflare routes through the Worker
3. Worker fetches origin response from Shopify → returns it to visitor
4. Worker POSTs { logs: [entry] } to https://log-collector.yourdomain.com/collect
   (non-blocking - visitor doesn't wait for this)
5. Cloudflare resolves log-collector.yourdomain.com via tunnel CNAME
6. Tunnel forwards request to localhost:9090 on your server
7. Receiver validates X-API-Key, writes JSON file to disk

Que datos de solicitudes de Shopify puedes capturar que Shopify no te muestra?

El panel de administracion de Shopify te muestra vistas de pagina, pedidos y fuentes de referencia. No te muestra que bots de IA visitaron, que paginas obtuvieron, de donde vinieron ni que tan rapido respondio tu servidor. Esta configuracion captura mas de 40 campos por solicitud en estas categorias:

Client Hints y Fetch Metadata son especialmente utiles para identificar navegadores headless y bots no firmados - los navegadores reales envian estos encabezados, la mayoria de los bots no.

Que bots de IA estan visitando tu tienda Shopify?

Shopify no distingue entre visitantes humanos y rastreadores de IA. Este Worker clasifica cada User-Agent en dos categorias que importan para la visibilidad de IA:

Las solicitudes de User-Agents no reconocidos se etiquetan como other / unknown - puedes analizarlos despues para encontrar rastreadores no firmados. Estos son datos que Shopify, Google Analytics y la mayoria de las plataformas de analitica SaaS simplemente no proporcionan.

Como almacenar datos de bots de Shopify en una base de datos para un analisis mas profundo

Para analiticas de bots mas profundas, puedes extender el Worker para registrar solicitudes de bots en Supabase (o cualquier base de datos) ademas de en disco. Agrega estos secretos del Worker:

wrangler secret put SUPABASE_URL
wrangler secret put SUPABASE_SERVICE_KEY

Luego agrega una funcion logToDatabase() que haga POST a la API REST de tu base de datos, llamada via ctx.waitUntil() para solicitudes de bots conocidos. Esto te da datos de bots estructurados y consultables junto con los archivos de registro sin procesar.

Como configurar Cloudflare DNS para una tienda Shopify con registro de solicitudes

Para que esta configuracion funcione, tu dominio debe estar proxied a traves de Cloudflare (nube naranja). Una configuracion tipica de DNS de Shopify + Cloudflare:

El CNAME www apunta a Shopify - Cloudflare hace proxy y cache. El CNAME log-collector apunta a tu tunnel - Cloudflare enruta el trafico de registros de forma segura a tu servidor.

Importante: La ruta del Worker debe coincidir con el hostname proxied (por ejemplo, www.yourdomain.com/*). No se activara en registros no proxied (nube gris).

Como monitorear y mantener tu pipeline de registros de Shopify

# Check receiver status
systemctl status log-receiver

# Check tunnel status
systemctl status cloudflared

# Tail live logs
journalctl -u log-receiver -f

# Count stored log files
ls /var/log/cdn-requests/*.json | wc -l

# Check disk usage
du -sh /var/log/cdn-requests/

Considera agregar una tarea cron para monitorear el uso del disco y alertar cuando el almacenamiento se acerque a tu limite.

Preguntas frecuentes

Por que los propietarios de tiendas Shopify no pueden acceder a los registros del servidor?

Shopify es una plataforma SaaS completamente administrada. Los propietarios de tiendas no tienen acceso a la infraestructura subyacente del servidor, lo que significa que no tienen acceso a los registros sin procesar de solicitudes HTTP, registros de acceso ni registros de errores. Shopify proporciona su propio panel de analitica con vistas de pagina, pedidos y datos de referencia, pero esto no incluye solicitudes HTTP individuales, user agents de bots, tiempos de respuesta ni datos geograficos a nivel de solicitud. No existe ningun plan de Shopify, incluido Shopify Plus, que proporcione acceso a los registros sin procesar del servidor. La unica forma de capturar estos datos es interceptar las solicitudes en la capa CDN antes de que lleguen a los servidores de origen de Shopify.

Como se rastrea el trafico de bots de IA en una tienda Shopify?

El trafico de bots de IA no se puede rastrear a traves de Google Analytics, Shopify Analytics ni ninguna herramienta de analitica JavaScript del lado del cliente porque los bots de IA no ejecutan JavaScript. El unico metodo confiable es el registro de solicitudes del lado del servidor. Para tiendas Shopify, esto significa interceptar solicitudes en la capa CDN usando un Cloudflare Worker (o una funcion de borde equivalente en otro CDN). El Worker registra cada solicitud entrante, incluido el encabezado User-Agent, que identifica bots de IA especificos como ChatGPT-User, GPTBot, ClaudeBot, PerplexityBot y otros. Este es el mismo enfoque utilizado por las plataformas emergentes de “analitica de agentes”, pero autoalojado y completamente bajo tu control.

Que bots de IA estan rastreando tiendas Shopify en este momento?

A partir de 2026, los principales bots de IA que visitan tiendas Shopify se dividen en dos categorias. Los bots de obtencion en tiempo real (ChatGPT-User, Claude-User, Perplexity-User) recuperan contenido bajo demanda durante conversaciones en vivo con usuarios. Los rastreadores de entrenamiento (GPTBot, ClaudeBot, PerplexityBot, Bytespider, Amazonbot, Applebot) recopilan contenido de forma programada para el entrenamiento de modelos y la construccion de indices. Sin registro del lado del servidor, ninguno de estos aparece en las analiticas de Shopify ni en Google Analytics.

Cuantos campos de datos registra Cloudflare por solicitud?

Esta configuracion captura mas de 40 campos por solicitud, incluyendo datos basicos de la solicitud (timestamp, metodo, URL, ruta, user agent, IP, referer), clasificacion de bots (nombre y tipo de bot), datos geograficos de Cloudflare (pais, region, ciudad, codigo postal, latitud, longitud, zona horaria, continente), informacion de red (ASN, organizacion, centro de datos, protocolo HTTP, version TLS), client hints (encabezados sec-ch-ua que ayudan a detectar navegadores headless), fetch metadata (encabezados sec-fetch que identifican solicitudes programaticas) y metricas de rendimiento (tiempo hasta el primer byte, tiempo de ida y vuelta TCP, estado de cache, estado de respuesta del origen).

Como se compara esto con las analiticas integradas de Shopify?

El panel de analiticas de Shopify muestra vistas de pagina, sesiones, tasas de conversion y fuentes de referencia. No muestra solicitudes HTTP individuales, user agents de bots, datos geograficos a nivel de solicitud, metricas de rendimiento de respuesta ni ninguna actividad de bots de IA. Google Analytics, que Shopify integra, tiene la misma limitacion porque depende de JavaScript del lado del cliente. Esta configuracion de registro basada en Cloudflare captura cada solicitud que toca tu dominio, incluidas las de bots que nunca ejecutan JavaScript, dandote una imagen completa que las herramientas de Shopify no pueden proporcionar.

Se puede usar esta configuracion con un CDN diferente a Cloudflare?

La arquitectura se aplica a cualquier CDN de borde que soporte funciones de borde y tuneles seguros. Los Cloudflare Workers tienen equivalentes en otras plataformas: Vercel Edge Functions, AWS CloudFront Functions, Fastly Compute y Akamai EdgeWorkers pueden interceptar solicitudes y enviar datos de registro. El componente de tunnel puede reemplazarse con cualquier metodo de conexion segura (tunnel SSH, VPN, endpoint HTTPS directo con lista de IPs permitidas). El patron fundamental es el mismo: interceptar en el borde, registrar asincronamente y enviar a tu propio receptor.