Chat de soporte: chat en vivo en tu web con una etiqueta

Un visitante tiene una duda a las once de la noche y tu formulario de contacto le parece un mensaje en una botella. El chat de soporte lo arregla: un botón de chat en cada página de tu web, y la conversación llega al CRM, donde tu equipo responde en tiempo real. Si ya añadiste widget.js para la edición en vivo, el chat está literalmente a cero líneas de código.

#Cómo funciona el chat de soporte

1. Un visitante hace clic en el botón de chat de la esquina de tu web y escribe un mensaje (con una captura de pantalla, si las palabras no le alcanzan).
2. El mensaje aparece al instante en CRM → Soporte → Chats. Todo va por WebSocket, así que nadie tiene que darle a F5.
3. Un operador responde desde el CRM y el visitante ve la respuesta al momento, con indicador de “escribiendo” y marcas de leído incluidos.

Para que nadie se pierda un chat mientras se prepara un café, los operadores tienen un contador de no leídos en el CRM, notificaciones del navegador y, si quieres, un bot de Telegram con horas de silencio. Todo eso se configura en el CRM, no en tu código.

#El chat y el modo de consentimiento

Si activaste el modo de consentimiento en la etiqueta del widget, el chat no se queda esperando al banner de cookies: el visitante puede escribir desde el primer segundo. Lo que cambia antes del consentimiento:

• Identidad de usar y tirar. El chat usa un id temporal que vive solo en memoria: no se guarda nada en el navegador. Una conversación anterior se sigue recuperando con su propio crm_chat_token.
• Sin atribución. Sin crm_vid ni crm_sid, el chat no queda vinculado al canal, las etiquetas UTM ni el enlace publicitario por el que llegó el visitante.

Dicho de otro modo: el soporte nunca depende de que alguien haya pulsado “Aceptar”; lo único que espera al consentimiento es la analítica.

#Añade un chat en vivo a tu web

No hay código específico para el chat. La misma etiqueta que mueve todo lo demás hace el trabajo:

<script src="https://widget.sitecog.com/widget.js" defer></script>

Cuando el chat está disponible para tu web, widget.js carga por su cuenta el bundle del chat (widget.support.js) y aparece un botón de chat flotante. Cuando no lo está, los visitantes no se descargan nada extra. Poner la etiqueta dos veces no hace daño: la segunda copia se ignora.

1. Comprueba que tu plan incluye el chat de soporte

   El chat está disponible en los planes que lo incluyen. Sin chat en el plan, no hay botón, diga lo que diga el código.

2. Comprueba que tu dominio es un sitio del CRM

   El chat reconoce tu web por el dominio en el que se abre la página (el Origin del navegador; el www. se ignora). El dominio tiene que ser un sitio que hayas añadido en el CRM.

3. Añade widget.js a la página

   La etiqueta de arriba, o las variantes de Next.js / Vite de Widget y marcado → Paso 1.

4. Dale estilo en el CRM

   Icono, colores, posición y textos viven en CRM → Soporte → Ajustes: lo vemos más abajo.

#Aspecto y textos en el CRM

Todo lo visual se configura en CRM → Soporte → Ajustes. Sin sobrescribir CSS y sin redesplegar: lo cambias ahí y el widget lo recoge.

#Textos por idioma e idioma de respaldo

Cada texto se puede rellenar para cada idioma de tu sitio. El widget elige el texto para el idioma del visitante así:

1. una coincidencia exacta de idioma;
2. si no, una coincidencia por las dos primeras letras;
3. si no, la primera entrada que hayas rellenado.

Si un texto está vacío, el widget usa su propio texto integrado. Así que puedes dejarlo todo en blanco y tener igualmente un chat de lo más decente: los ajustes son para cuando quieres que suene a ti.

#Respuesta automática

Activa la respuesta automática y escribe un texto por idioma (hasta 1000 caracteres). Responde al primer mensaje de una conversación nueva, para que el visitante sepa que se le ha escuchado aunque todo el equipo esté en una reunión. Una conversación cuenta como nueva tras N minutos de silencio: tú eliges N entre 1 y 180; por defecto son 5.

#Cuando no hay nadie conectado

Un chat en vivo sin nadie al otro lado es una trampa: el visitante escribe su pregunta, espera, cierra la pestaña… y nunca sabrás quién era. El modo sin conexión convierte el chat en un formulario de “déjanos tu correo” justo en esos momentos, para que la pregunta no desaparezca junto con el visitante.

Se activa en CRM → Soporte → Ajustes → “Cuando no hay nadie conectado”. El chat pasa al modo sin conexión cuando:

• ningún operador tiene el CRM abierto para este sitio. Cuenta cualquier página del CRM, no solo los chats: el operador está “conectado” hasta que cierra la última pestaña del CRM;
• está fuera del horario laboral, si lo configuras: días laborables, desde / hasta y una zona horaria. El horario es opcional; sin él solo se aplica la primera regla. Fuera de horario el chat está sin conexión aunque alguien tenga el CRM abierto por casualidad.

Qué cambia en el modo sin conexión:

1. El widget muestra “Ahora no estamos conectados: deja tu correo y te responderemos” y pide el correo antes del mensaje. Sin correo no hay mensaje: si no, la respuesta no tendría adónde ir.
2. En el CRM el chat lleva la marca “Solicitud sin conexión”, con el correo del visitante justo al lado.
3. La notificación de Telegram (si conectaste el bot) sale de inmediato: un chat así está esperando por definición.

Mientras haya operadores conectados, el chat funciona como siempre y el correo es opcional: el visitante puede pulsar igualmente “Recibir respuestas por correo”, algo muy útil para quien está a punto de cerrar la pestaña.

#Respuestas por correo

Si el visitante dejó su correo y no ha leído la respuesta del operador en el widget en unos 2 minutos, se la enviamos por correo. Varias respuestas seguidas llegan en un solo correo, no como una ráfaga de avisos. El correo contiene solo las respuestas del operador, no toda la conversación, y un enlace a la página de tu web desde la que escribió el visitante, para que pueda seguir allí mismo.

#Idioma del widget

El widget habla el idioma de tu página: lee <html lang> y se queda con las dos primeras letras, así que en-GB y en significan inglés por igual.

• Hay textos de interfaz integrados para ru, en, uk, es, de y zh. Cualquier otro idioma recibe inglés.
• Tus propios textos del CRM siguen las reglas de respaldo de arriba.
• ¿Una SPA con selector de idioma? Basta con actualizar document.documentElement.lang: el widget detecta el cambio y redibuja sus textos sobre la marcha, sin recargar.

function setLanguage(lang) {
  // ...cambia tus propias traducciones...
  document.documentElement.lang = lang; // el chat te sigue
}

#Identifica a los usuarios con sesión iniciada

Por defecto, un operador ve “Visitante”. Si tu web tiene cuentas, puedes hacerlo mejor: pon el nombre del usuario y tu id interno en localStorage y el operador verá con quién está hablando.

El widget solo lee estas claves. Las envía al conectarse y otra vez antes de cada mensaje si han cambiado, así que da igual si las pones antes de que cargue la página o justo después de que el usuario inicie sesión. Al cerrar sesión, borra las dos claves: si no, la siguiente persona en el mismo ordenador hereda el nombre.

// support-identity.js
function setSupportIdentity(user) {
  try {
    if (user) {
      localStorage.setItem('support_client_name', user.name.slice(0, 80));
      localStorage.setItem('support_client_id', String(user.id).slice(0, 64));
    } else {
      localStorage.removeItem('support_client_name');
      localStorage.removeItem('support_client_id');
    }
  } catch {
    // El almacenamiento está bloqueado (ajustes de privacidad estrictos): el chat sigue funcionando, solo que de forma anónima
  }
}

// Tras iniciar sesión correctamente
setSupportIdentity({ id: 'user_8421', name: 'Anna Schmidt' });

// Al cerrar sesión
setSupportIdentity(null);

import { useEffect } from 'react';

type User = { id: string; name: string };

// user: undefined = aún cargando, null = sin sesión, objeto = con sesión
export function useSupportIdentity(user: User | null | undefined) {
  useEffect(() => {
    if (user === undefined) return; // no borres las claves mientras la autenticación sigue cargando
    try {
      if (user) {
        localStorage.setItem('support_client_name', user.name.slice(0, 80));
        localStorage.setItem('support_client_id', user.id.slice(0, 64));
      } else {
        localStorage.removeItem('support_client_name');
        localStorage.removeItem('support_client_id');
      }
    } catch {
      // El almacenamiento está bloqueado: el chat sigue siendo anónimo, no se rompe nada
    }
  }, [user]);
}

// En el shell de tu app:
// const { user } = useAuth();
// useSupportIdentity(user);

// app/support-identity.tsx
'use client';

import { useEffect } from 'react';

export function SupportIdentity({ id, name }: { id?: string; name?: string }) {
  useEffect(() => {
    try {
      if (id && name) {
        localStorage.setItem('support_client_name', name.slice(0, 80));
        localStorage.setItem('support_client_id', id.slice(0, 64));
      } else {
        localStorage.removeItem('support_client_name');
        localStorage.removeItem('support_client_id');
      }
    } catch {}
  }, [id, name]);

  return null; // no renderiza nada, solo sincroniza las claves
}

// app/layout.tsx: un Server Component conoce la sesión con certeza
// const user = await getCurrentUser(); // tu autenticación
// ...
// <body>
//   {children}
//   <SupportIdentity id={user?.id} name={user?.name} />
//   <Script src="https://widget.sitecog.com/widget.js" strategy="afterInteractive" />
// </body>

#Adjuntos y límites

Los visitantes pueden adjuntar archivos a sus mensajes: una captura del error vale más que mil palabras.

Los límites son generosos para las personas y fastidiosos para los bots, que es justo la idea. Una oficina llena de gente detrás de una sola IP con la web abierta en una docena de pestañas es el único caso en el que podrías notar el límite de conexiones.

#Abrir el chat desde tu propio botón

El botón redondo de la esquina le va bien a la mayoría de las webs, pero a veces el chat pide encajar en tu propio diseño: un enlace “Habla con nosotros” en la cabecera, un botón en la página de precios, un icono de ayuda en la app. Hay dos formas de hacerlo, y una no necesita ni una línea de JavaScript.

#Sin JavaScript: data-crm-chat

Pon data-crm-chat en cualquier elemento y un clic abrirá el chat:

<a href="/contacts" data-crm-chat="open">Habla con nosotros</a>

<button type="button" data-crm-chat="toggle">💬 Soporte</button>

• open (también el valor por defecto si lo dejas vacío), close o toggle.
• Los elementos que se añaden más tarde (modales, rutas del lado del cliente) también funcionan: el widget escucha todo el documento.
• Plan B incorporado. Si el chat no está disponible en la web (o widget.js está bloqueado), el clic no se intercepta y el enlace simplemente va a su href. Apúntalo a tu página de contacto y nadie se topará con un botón muerto.

#Desde JavaScript: window.crmChat

widget.js crea window.crmChat al instante, antes de que se cargue el propio chat. Las llamadas que se hagan en ese primer segundo se guardan y se ejecutan en cuanto el chat está listo, así que un clic en tu botón nunca se pierde. En el modo Live del CRM el chat no se carga en absoluto y crmChat simplemente no hace nada: tu código tampoco se romperá ahí.

document.querySelector('#help').addEventListener('click', () => {
  // ?. por si un bloqueador de anuncios no dejó cargar widget.js
  window.crmChat?.open();
});

export function HelpButton() {
  return (
    <button type="button" onClick={() => window.crmChat?.open()}>
      ¿Necesitas ayuda?
    </button>
  );
}

#Oculta el botón integrado

¿Tienes tu propio botón? Oculta el botón redondo del widget con data-chat-button="hidden" en la misma etiqueta script. El panel se sigue abriendo y cerrando como siempre: tiene su propia × en la cabecera.

<script src="https://widget.sitecog.com/widget.js" data-chat-button="hidden" defer></script>

import Script from 'next/script';

<Script src="https://widget.sitecog.com/widget.js" data-chat-button="hidden" strategy="afterInteractive" />

#Muestra las respuestas sin leer en tu botón

Sin el botón redondo, el visitante necesita otra forma de enterarse de que el operador ha contestado. El widget lanza un evento crm:chat en window cada vez que algo cambia, con { available, open, unread } en detail. Úsalo para un contador y para ocultar tu botón cuando el chat no esté disponible.

import { useEffect, useState } from 'react';

type ChatState = { available: boolean | null; open: boolean; unread: number };

export function useCrmChat(): ChatState {
  const [state, setState] = useState<ChatState>({ available: null, open: false, unread: 0 });

  useEffect(() => {
    const api = window.crmChat;
    if (api) setState({ available: api.available, open: api.isOpen(), unread: api.unread });

    const onChange = (e: Event) => setState((e as CustomEvent<ChatState>).detail);
    window.addEventListener('crm:chat', onChange);
    return () => window.removeEventListener('crm:chat', onChange);
  }, []);

  return state;
}

// Uso
export function ChatButton() {
  const { available, unread } = useCrmChat();
  if (available === false) return null;

  return (
    <button type="button" onClick={() => window.crmChat?.open()}>
      Soporte {unread > 0 && <span className="badge">{unread}</span>}
    </button>
  );
}

#Content Security Policy para el chat

¿Tu web no tiene CSP? Sáltate esta sección. Si la tiene, el chat necesita estas fuentes:

script-src  https://widget.sitecog.com
connect-src https://back.sitecog.com wss://back.sitecog.com
style-src   'unsafe-inline'
img-src     <el host desde el que se sirven los archivos de tu CRM>

• script-src: para cargar widget.js y el bundle del chat.
• connect-src: para la petición de ajustes y el WebSocket. Fíjate en la entrada wss://: https:// por sí solo no cubre los WebSockets.
• style-src: la ventana del chat vive en un shadow DOM con un <style> inline, así que una política estricta puede necesitar 'unsafe-inline' (por ejemplo, style-src 'self' 'unsafe-inline').
• img-src: los adjuntos y el icono propio se sirven desde el almacenamiento de archivos de tu sitio. Abre cualquier imagen del CRM y permite su host.

#Avanzado: monta tu propia interfaz de chat

Un cliente propio son tres pasos, y uno más cuando no hay nadie conectado:

1. Lee los ajustes

   ¿Está activado el chat para este sitio? ¿Qué dicen los textos? ¿Hay alguien conectado?

2. Inicia un chat

   Consigue un token de chat por HTTP y guárdalo.

3. Deja un correo, en modo sin conexión

   ¿Ahora no puede responder nadie? Guarda el correo del visitante antes de su primer mensaje.

4. Habla por el WebSocket

   Conéctate con el token, envía y recibe frames.

Todos los endpoints de soporte son públicos: no hay clave de API. El sitio se reconoce por la cabecera Origin del navegador (con Referer como alternativa), así que llámalos desde páginas de tu dominio real. Un dominio que no es un sitio del CRM recibe 400 con {"message":"unknown_domain"}; una petición sin ningún origen recibe {"message":"unknown_origin"}.

#1. Lee los ajustes del chat

GET https://back.sitecog.com/support/config?lang=en

{
  "enabled": true,
  "look": {
    "icon": "bubble",
    "iconUrl": null,
    "position": "bottom-right",
    "skin": "indigo",
    "texts": {
      "title": null,
      "subtitle": null,
      "placeholder": null,
      "greeting": null
    }
  },
  "offline": {
    "form": true,
    "away": true,
    "reason": "no_agents"
  }
}

{ "enabled": false }

#2. Inicia o reanuda un chat

POST https://back.sitecog.com/support/chat/start
Content-Type: application/json

{
  "visitorId": "5f1c2a9e-3b7d-4c1e-9a0f-8d2b6e4c7a10",
  "lang": "en",
  "token": "<el token que recibiste la última vez, si lo tienes>"
}

{
  "enabled": true,
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9…",
  "chatId": 123,
  "lastSeq": 5,
  "readSeq": 5,
  "status": "open",
  "messages": [
    { "seq": 1, "author": "visitor", "text": "Hi! Do you ship to Austria?", "at": "2026-10-01T09:12:03.000Z" },
    { "seq": 2, "author": "agent", "text": "Hi Anna! Yes, 2–4 days.", "at": "2026-10-01T09:13:40.000Z" }
  ],
  "email": null,
  "offline": { "form": true, "away": false, "reason": null }
}

#3. Deja un correo

Cuando offline.away es true, guarda el correo del visitante antes de enviar su primer mensaje: es lo que hace el widget integrado, y la única forma de que la respuesta llegue a alguien que ya cerró la pestaña. Mientras haya operadores conectados, la misma llamada sirve para un botón opcional de “Recibir respuestas por correo”.

POST https://back.sitecog.com/support/chat/contact
Content-Type: application/json

{
  "token": "<token del chat de chat/start>",
  "email": "anna@example.com",
  "page": "https://shop.example/delivery?utm_source=newsletter"
}

{ "ok": true, "email": "anna@example.com" }

{ "ok": false, "error": "invalid_email" }

// chat: la respuesta de chat/start (o un frame ready más reciente)
async function sendFirstMessage(text, email) {
  if (chat.offline.away && !chat.email) {
    const res = await fetch('https://back.sitecog.com/support/chat/contact', {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ token: chatToken, email, page: location.href }),
    }).then((r) => r.json());

    if (!res.ok) return showEmailError(res.error); // no perdemos el mensaje, que corrija la dirección
    chat.email = res.email;
  }
  send(text); // el frame send del WebSocket, paso 4
}

#4. Conéctate al WebSocket

wss://back.sitecog.com/support/ws

El token va en la lista de subprotocolos, no en la URL: las URL acaban en los logs y los subprotocolos no. Pasa dos subprotocolos: la versión del protocolo y token. + tu token de chat. El navegador envía Origin por su cuenta, y tiene que ser tu sitio.

const socket = new WebSocket('wss://back.sitecog.com/support/ws', [
  'crm.support.v1',
  'token.' + chatToken,
]);

socket.onopen = () => {
  // Saluda y dile al servidor cuál es el último mensaje que ya tienes
  socket.send(JSON.stringify({ t: 'hello', since: lastSeq }));
};

Tras el hello, el servidor responde con un frame ready que contiene todo lo que te perdiste desde since. Cada frame es un objeto JSON con su tipo en t, de 8 KB como máximo. El servidor manda un ping cada 25 segundos; los navegadores responden a los pings solos, no tienes que hacer nada.

#Frames que envías

{ "t": "hello", "since": 5 }
{ "t": "send", "id": "m-1727775123-1", "text": "Do you ship to Austria?" }
{ "t": "read", "seq": 7 }
{ "t": "typing" }
{ "t": "history", "before": 51 }
{ "t": "profile", "name": "Anna Schmidt", "contact": "anna@example.com", "clientId": "user_8421" }

#Frames que recibes

{
  "t": "message",
  "chatId": 123,
  "m": { "seq": 6, "author": "agent", "text": "Your parcel left the warehouse today 🚚", "at": "2026-10-01T09:20:11.000Z" }
}

#Un cliente mínimo completo

Iniciar → conectar → enviar → recibir, con reconexiones. Unas 90 líneas, sin dependencias: enchufa tus propios render y markSent y tendrás un chat funcionando.

const SUPPORT = 'https://back.sitecog.com/support';
const WS_URL = 'wss://back.sitecog.com/support/ws';

const store = {
  get: (k) => { try { return localStorage.getItem(k); } catch { return null; } },
  set: (k, v) => { try { localStorage.setItem(k, v); } catch {} },
  del: (k) => { try { localStorage.removeItem(k); } catch {} },
};

// Reutiliza el id de visitante del widget si está; si no, guarda el nuestro
function visitorId() {
  let id = store.get('crm_vid') || store.get('my_chat_vid');
  if (!id) {
    id = crypto.randomUUID();
    store.set('my_chat_vid', id);
  }
  return id;
}

let socket = null;
let lastSeq = 0;
let failures = 0;
const seen = new Set();

function show(m) {
  if (seen.has(m.seq)) return; // el mismo mensaje puede llegar de start, ready y message
  seen.add(m.seq);
  lastSeq = Math.max(lastSeq, m.seq);
  render(m); // tu interfaz: m.author, m.text (¡como texto!), m.at, m.file
}

async function boot() {
  const res = await fetch(SUPPORT + '/chat/start', {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({
      visitorId: visitorId(),
      lang: (document.documentElement.lang || 'en').slice(0, 2),
      token: store.get('my_chat_token') || undefined,
    }),
  });
  const data = await res.json();
  if (!data.enabled) return;            // el chat está desactivado para este sitio
  if (data.error) throw new Error(data.error);

  store.set('my_chat_token', data.token); // válido 180 días
  data.messages.forEach(show);
  lastSeq = Math.max(lastSeq, data.lastSeq);
  connect(data.token);
}

function connect(token) {
  socket = new WebSocket(WS_URL, ['crm.support.v1', 'token.' + token]);

  socket.onopen = () => {
    failures = 0;
    socket.send(JSON.stringify({ t: 'hello', since: lastSeq }));
  };

  socket.onmessage = (event) => {
    const frame = JSON.parse(event.data);
    if (frame.t === 'ready') frame.messages.forEach(show);
    else if (frame.t === 'message') show(frame.m);
    else if (frame.t === 'ack') markSent(frame.id, frame.seq);
    else if (frame.t === 'chat_gone') {
      store.del('my_chat_token');
      socket.onclose = null;
      socket.close();
      boot();                           // un chat completamente nuevo
    } else if (frame.t === 'error') console.warn('[chat]', frame.code, frame.id);
  };

  socket.onclose = (event) => {
    if (event.code === 4402 || event.code === 4403) return; // desactivado / prohibido: paramos
    failures += 1;
    const delay = Math.min(30000, 1000 * 2 ** failures) + Math.random() * 1000;
    // Varios fallos seguidos pueden significar que el token ya no vale: empezamos de nuevo
    setTimeout(() => (failures > 3 ? boot() : connect(token)), delay);
  };
}

function send(text) {
  const id = crypto.randomUUID();       // se puede reenviar: mismo id = mismo mensaje
  socket.send(JSON.stringify({ t: 'send', id, text }));
  return id;                            // muéstralo como "enviando…" hasta el ack con este id
}

boot();

#Reconexiones y mensajes perdidos

• Guarda el seq más alto que hayas mostrado. Tras reconectar, envía { "t": "hello", "since": lastSeq }: el frame ready trae exactamente lo que te perdiste.
• Si ready.gap es true, te has perdido mucho; rellena el hueco con peticiones history.
• Los mensajes pueden llegar dos veces (de chat/start y de ready, por ejemplo). Elimina duplicados por seq.
• Espera cada vez más entre intentos (1 s, 2 s, 4 s… con algo de aleatoriedad): un reinicio del servidor no debería convertirse en una estampida de reconexiones.
• ¿No sabes si un mensaje llegó al servidor? Envíalo de nuevo con el mismo id. Se guarda una sola vez.

#Adjuntos en una interfaz propia

Un archivo va en tres saltos cortos: consigue un permiso, sube el archivo y envía el recibo.

// 1. Un permiso para subir: válido durante 5 minutos
const { permit } = await fetch('https://back.sitecog.com/support/chat/upload-permit', {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ token: chatToken }),
}).then((r) => r.json());

// 2. Sube el archivo (imágenes o documentos, hasta 10 MB)
const form = new FormData();
form.append('file', fileInput.files[0]);
const upload = await fetch('https://back.sitecog.com/storage/support/upload', {
  method: 'POST',
  headers: { 'x-support-permit': permit },
  body: form,
}).then((r) => r.json());
// upload = { receipt, url, name, mime, size, kind }

// 3. Envía un mensaje con el recibo (el texto puede ir vacío)
socket.send(JSON.stringify({ t: 'send', id: crypto.randomUUID(), text: '', file: upload.receipt }));

#Errores y códigos de cierre

Los errores en una conexión activa llegan como { "t": "error", "code": "…", "id": "…" }:

La propia conexión puede rechazarse o cerrarse:

#Solución de problemas

#No aparece el botón del chat

• El plan no incluye el chat, o el chat está desactivado. El endpoint de ajustes responde { "enabled": false }.
• Dominio desconocido. La página se abre en un dominio que no es un sitio del CRM: un host de staging, localhost, un dominio nuevo que aún no has añadido. (El www. da igual, se quita).
• Lo bloquea la CSP. Busca “Refused to load” o “Refused to connect” en la consola del navegador y revisa la sección de CSP.
• Estás mirando la web dentro del CRM. En el modo Live el widget solo carga el editor: ni chat ni analítica. Abre la web en una pestaña normal. (El editor, por cierto, solo se carga en el frame Live del propio CRM: si otra web mete la tuya en su iframe, allí no hay editor).
• Falta widget.js en esta página: es fácil que se escape cuando una web tiene varios layouts.
• Acabas de activar el chat y tu navegador aún recuerda los ajustes antiguos durante hasta ~10 minutos (mira más abajo).

Puedes preguntarle directamente al servidor qué opina de tu dominio:

curl "https://back.sitecog.com/support/config?lang=en" -H "Origin: https://your-site.com"

#No se ven los cambios hechos en el CRM

• Los ajustes se guardan en caché en el navegador durante unos 10 minutos. Espera, o borra la clave crm_chat_cfg en DevTools → Application → Local Storage y recarga.
• Has editado los textos de un idioma, pero la página tiene otro <html lang>. Revisa las reglas de respaldo.
• Un campo de texto está vacío, así que el widget muestra su texto integrado: es así por diseño.