Inyección de marcadores: prellenar los marcadores del navegador

BotBrowser puede sembrar al iniciar un estado de marcadores documentado, pero no puede hacer que un sitio lo interprete o considere fiable. Esta guía trata los marcadores como una entrada del estado del navegador, con límites explícitos de privacidad y reproducibilidad.

Resumen

• Mantén el JSON pequeño, revisable y vinculado a un perfil identificado.
• Comprueba el árbol resultante en el navegador, no solo el éxito del lanzamiento.
• Los marcadores no prueban una identidad ni garantizan el comportamiento de un sitio.

Contenido

• Por qué una barra de marcadores vacía es un punto de partida desigual
• Cómo almacena Chromium los marcadores
• Cómo funciona --bot-bookmarks
• Lanzar, validar y comprobar marcadores prellenados
• Preguntas sobre el prellenado de marcadores
• Conclusión práctica

Por qué una barra de marcadores vacía es un punto de partida desigual

Un navegador que se usa a diario acumula marcadores durante semanas y meses. Se ordenan en carpetas y reflejan la región, el trabajo y los intereses del usuario. Una instancia lanzada desde cero para automatización o investigación de privacidad empieza con la barra de marcadores vacía, un estado distinto del que describe el resto del perfil. Si el perfil indica un desarrollador germanohablante en Berlín, una barra vacía es una pequeña incoherencia dentro de una configuración que por lo demás es consistente.

BotBrowser ofrece el flag --bot-bookmarks para prellenar el almacén de marcadores cuando el navegador arranca. El flag recibe un array JSON de entradas url y folder, de modo que cada sesión de prueba puede partir de un estado de marcadores que tú escribiste y puedes reproducir.

Los marcadores como una capa más del estado del navegador

Una sesión de navegador tiene varias capas de estado: cookies, localStorage, IndexedDB, historial de navegación, locale, zona horaria, configuración de red y marcadores. Cada capa es un dato independiente y puede fijarse por separado. Los marcadores son de las capas más sencillas de controlar, porque son datos simples con una estructura pequeña y no cambian mientras corre un script, salvo que algo escriba en ellos.

Para quienes investigan privacidad, controlar el estado de los marcadores es importante para obtener experimentos reproducibles. Si comparas cómo se comporta un sitio con un navegador completamente nuevo y con uno que tiene algo de historial, necesitas saber exactamente qué estado difirió entre las dos ejecuciones. Escribir el conjunto de marcadores en los argumentos de lanzamiento convierte una diferencia invisible en una diferencia registrada que puedes revisar, versionar y repetir.

Para los equipos que manejan varias identidades, cada una gana con un conjunto de marcadores acorde con el resto de su perfil. Un perfil en alemán con zona horaria de Berlín y locale alemán es más fácil de razonar cuando sus marcadores apuntan a sitios alemanes. Una persona desarrolladora es más fácil de razonar si sus marcadores son técnicos. El objetivo es una configuración coherente y documentada. No es una promesa sobre cómo reaccionará ningún sitio web.

Las barras de marcadores vacías también son un problema práctico en algunos flujos. Si necesitas ejercitar elementos de interfaz relacionados con marcadores, como la barra, el gestor o las sugerencias del omnibox, un almacén prellenado te da material con el que trabajar desde la primera carga de página.

Cómo almacena Chromium los marcadores

El archivo Bookmarks

Chromium guarda los marcadores en un archivo JSON llamado Bookmarks dentro de la carpeta del perfil en el directorio de datos de usuario, por ejemplo Default/Bookmarks. El archivo contiene un árbol cuyos nodos raíz incluyen bookmark_bar, que se muestra en la barra de marcadores, y other, la carpeta "Otros marcadores" (un nodo raíz synced guarda los marcadores del móvil). Las páginas de Chrome y de BotBrowser citadas al final de este artículo no documentan este formato en disco, así que toma los nombres de campo siguientes como contexto y compruébalos en un archivo Bookmarks de tu propia carpeta de perfil.

Cada entrada del árbol tiene estas propiedades:

• name: El texto que se muestra en la barra o en el gestor de marcadores
• url: La URL de destino para los marcadores de tipo URL
• type: url para un marcador o folder para una carpeta con hijos
• children: Un array de marcadores y carpetas anidados (para entradas de tipo carpeta)
• date_added: Una marca de tiempo con el momento de creación del marcador

Cuando el navegador arranca, lee este archivo y rellena la barra y el gestor de marcadores. Chromium también guarda metadatos internos para cada entrada, como un identificador y una marca de tiempo en su formato interno. Esos metadatos son la razón por la que los archivos Bookmarks escritos a mano fallan con facilidad de forma sutil.

Dónde aparecen los marcadores prellenados

Los marcadores aparecen en varios lugares del navegador:

1. Barra de marcadores: El lugar más visible, debajo de la barra de direcciones cuando está activada
2. Gestor de marcadores: Accesible mediante chrome://bookmarks
3. Sugerencias del omnibox: La barra de direcciones puede sugerir URL marcadas mientras escribes

El gestor de marcadores es el sitio más fiable para confirmar una entrada prellenada, porque lista todo el árbol, carpetas incluidas. Los otros lugares dependen de ajustes de la interfaz.

Formas de prellenar marcadores sin el flag

Editar el archivo Bookmarks a mano

Puedes crear un directorio de datos de usuario, escribir o editar el archivo JSON Bookmarks y lanzar el navegador con ese directorio. Funciona, pero tiene costes:

• El formato incluye campos de metadatos, como identificadores y marcas de tiempo en el formato interno de Chromium, que deben ser correctos
• Tienes que gestionar los directorios de datos de usuario de forma explícita y llevar el registro de qué directorio corresponde a qué identidad
• No hay una separación limpia entre los datos de marcadores y el resto del estado persistido en el mismo directorio

Usar la API chrome.bookmarks

La API chrome.bookmarks puede crear marcadores de forma programática, pero la documentación de Chrome la presenta como una API de extensiones. No está disponible para el JavaScript normal de una página ni para los frameworks de automatización. Usarla implica instalar una extensión y concederle el permiso de marcadores, lo que añade un componente que luego hay que mantener, revisar y sincronizar entre identidades.

Manejar la interfaz de marcadores desde un framework

Ni Playwright ni Puppeteer exponen una API de marcadores. Con estos frameworks la única vía integrada es abrir chrome://bookmarks y recorrer la interfaz con clics, algo lento y frágil que además hay que repetir en cada sesión nueva.

Cómo funciona --bot-bookmarks

BotBrowser resuelve el prellenado de marcadores con el flag --bot-bookmarks, así que no hace falta ninguna de las tres vías anteriores.

Prellenado al lanzar

Cuando se pasa --bot-bookmarks, BotBrowser lee el valor JSON y rellena el almacén de marcadores del navegador en el arranque. Las entradas quedan disponibles en el gestor de marcadores y en cualquier otro lugar donde tu configuración muestre marcadores.

El formato JSON

El flag acepta una cadena JSON que describe la estructura de marcadores:

--bot-bookmarks='[{"title":"Google","type":"url","url":"https://www.google.com"},{"title":"News","type":"folder","children":[{"title":"BBC","type":"url","url":"https://www.bbc.com"},{"title":"Reuters","type":"url","url":"https://www.reuters.com"}]}]'

Cada entrada tiene un title y un type. Una entrada url necesita además un url, y una entrada folder necesita un array children con más entradas. La documentación pública de Bookmark Seeding describe los campos así:

• title (obligatorio): Nombre visible del marcador o de la carpeta
• type (obligatorio): url o folder
• url (obligatorio en entradas url): La URL del marcador
• children (obligatorio en entradas folder): Array de entradas hijas

Las carpetas pueden contener otras carpetas, de modo que una estructura como Trabajo, luego Proyectos y después enlaces individuales se expresa en un único valor.

Sin extensión de por medio

Como el prellenado ocurre dentro del navegador al arrancar, no hay que instalar ni mantener ninguna extensión. El conjunto de extensiones instaladas sigue siendo el que tú elegiste, y el estado de los marcadores queda descrito por completo en los argumentos de lanzamiento.

Junto con otros ajustes de identidad

Los marcadores se combinan de forma natural con otros ajustes de lanzamiento. Una configuración de identidad completa puede incluir marcadores, cookies, historial de navegación, zona horaria, locale y configuración de red, cada uno fijado de forma explícita para que la sesión sea coherente internamente.

Lanzar, validar y comprobar marcadores prellenados

Una barra corta

chrome --bot-profile="path/to/profile.enc" \
       --bot-bookmarks='[{"title":"Google","type":"url","url":"https://www.google.com"},{"title":"YouTube","type":"url","url":"https://www.youtube.com"}]'

Carpetas anidadas

chrome --bot-profile="path/to/profile.enc" \
       --bot-bookmarks='[{"title":"Google","type":"url","url":"https://www.google.com"},{"title":"News","type":"folder","children":[{"title":"BBC","type":"url","url":"https://www.bbc.com"},{"title":"Reuters","type":"url","url":"https://www.reuters.com"}]},{"title":"Shopping","type":"folder","children":[{"title":"Amazon","type":"url","url":"https://www.amazon.com"}]}]'

Desde Puppeteer

const puppeteer = require('puppeteer-core');

const bookmarks = JSON.stringify([
  { title: 'Google', type: 'url', url: 'https://www.google.com' },
  { title: 'YouTube', type: 'url', url: 'https://www.youtube.com' },
  {
    title: 'News',
    type: 'folder',
    children: [
      { title: 'BBC', type: 'url', url: 'https://www.bbc.com' },
      { title: 'Reuters', type: 'url', url: 'https://www.reuters.com' },
    ],
  },
]);

(async () => {
  const browser = await puppeteer.launch({
    executablePath: 'path/to/botbrowser/chrome',
    args: ['--bot-profile=path/to/profile.enc', `--bot-bookmarks=${bookmarks}`],
    headless: true,
    defaultViewport: null,
  });

  const page = await browser.newPage();
  await page.goto('https://example.com');
  await browser.close();
})();

Ejemplo combinado con otros ajustes de identidad

chrome --bot-profile="path/to/profile.enc" \
       --bot-bookmarks='[{"title":"Google","type":"url","url":"https://www.google.de"},{"title":"Amazon","type":"url","url":"https://www.amazon.de"}]' \
       --bot-inject-random-history \
       --bot-cookies="@path/to/cookies.json" \
       --bot-timezone=Europe/Berlin \
       --bot-locale=de-DE \
       --bot-languages=de-DE,de,en \
       --proxy-server=socks5://user:pass@de-proxy:1080

En esta combinación todos los ajustes regionales apuntan a Alemania: los marcadores, la zona horaria, el locale, la lista de idiomas y la salida de red. El ejemplo sirve para mostrar que las capas concuerdan entre sí. No garantiza cómo tratará un sitio la sesión.

De estos flags, --bot-cookies y --bot-inject-random-history son PRO, y --bot-timezone, --bot-locale y --bot-languages son ENT Tier1, así que la combinación completa requiere un plan que los incluya. --bot-bookmarks en sí es Core.

Construir el JSON sin errores de comillas

Una fuente habitual de problemas con --bot-bookmarks es el propio valor JSON. Tres hábitos ayudan a evitar casi todos.

Primero, no escribas el JSON a mano dentro de un comando de shell cuando pase de unas pocas entradas. Construye una estructura de datos normal en tu script y serialízala con JSON.stringify(), como hace el ejemplo de Puppeteer. La documentación de Bookmark Seeding da el mismo consejo: usa JSON.stringify() para construir el valor y no lo envuelvas en comillas adicionales.

Segundo, cuando sí escribas el valor en un shell, envuélvelo entre comillas simples para que las comillas dobles del JSON sobrevivan. Un título con apóstrofo rompe esa envoltura, otra razón para serializar desde código.

Tercero, valida la estructura antes de lanzar. Una comprobación pequeña detecta los dos errores que la documentación señala como causas típicas de marcadores ausentes: entradas sin title o type, y carpetas cuyo array children contiene entradas no válidas.

function validateBookmarks(entries, path = 'root') {
  if (!Array.isArray(entries)) throw new Error(`${path}: expected an array`);
  entries.forEach((entry, index) => {
    const where = `${path}[${index}]`;
    if (!entry.title) throw new Error(`${where}: missing title`);
    if (entry.type === 'url') {
      if (!entry.url) throw new Error(`${where}: url entries need a url`);
    } else if (entry.type === 'folder') {
      if (!Array.isArray(entry.children)) throw new Error(`${where}: folder entries need a children array`);
      validateBookmarks(entry.children, `${where}.children`);
    } else {
      throw new Error(`${where}: type must be "url" or "folder"`);
    }
  });
  return entries;
}

const bookmarks = JSON.stringify(validateBookmarks(entries));

Ejecutar la comprobación antes de cada lanzamiento convierte una carpeta vacía y silenciosa en un mensaje de error con la ruta de la entrada defectuosa. En una matriz de pruebas que lanza muchas sesiones, eso marca la diferencia entre una corrección rápida y una larga búsqueda entre resultados.

Elegir conjuntos de marcadores por identidad

Los marcadores prellenados funcionan mejor cuando siguen las mismas decisiones que el resto del perfil. Una forma práctica de mantenerlo manejable es definir en un solo lugar un conjunto con nombre por identidad y consultarlo al lanzar:

const sets = {
  de: [
    { title: 'Google', type: 'url', url: 'https://www.google.de' },
    { title: 'Spiegel', type: 'url', url: 'https://www.spiegel.de' },
    { title: 'Amazon', type: 'url', url: 'https://www.amazon.de' },
  ],
  us: [
    { title: 'Google', type: 'url', url: 'https://www.google.com' },
    { title: 'Reuters', type: 'url', url: 'https://www.reuters.com' },
    { title: 'Amazon', type: 'url', url: 'https://www.amazon.com' },
  ],
};

const args = ['--bot-profile=path/to/profile.enc', `--bot-bookmarks=${JSON.stringify(sets[identity])}`];

Algunas pautas para construir los conjuntos:

• Elige sitios que una persona de esa región, idioma y rol guardaría con verosimilitud, como un medio de noticias nacional, una tienda local o un sitio de documentación.
• Usa el dominio regional cuando exista. Una identidad alemana que apunta a una tienda alemana es más fácil de explicar que una que solo apunta al sitio global.
• Mantén los conjuntos lo bastante pequeños para revisarlos. Entre diez y cincuenta entradas es un rango manejable a mano, y un conjunto corto se compara mejor entre ejecuciones.
• Usa carpetas donde la persona las usaría, por ejemplo una carpeta de trabajo para un desarrollador o una de compras para un perfil de consumidor.
• Guarda cada conjunto en control de versiones junto a la configuración de lanzamiento, para poder rastrear siempre un resultado hasta el estado exacto de marcadores que lo produjo.

Un ejemplo práctico muestra cómo encaja esto en un plan de pruebas. Supón que quieres comparar dos ejecuciones de la misma página: una con la barra de marcadores vacía y otra con el conjunto alemán de arriba. Lanza ambas con el mismo perfil, zona horaria y locale, cambia solo el valor de --bot-bookmarks y guarda los dos comandos en tus notas. Abre chrome://bookmarks en cada ejecución para confirmar que el estado realmente fue distinto y luego compara el resultado que estés estudiando. Si coinciden, has aprendido que el estado de los marcadores no influyó en esa página. Si difieren, tienes una diferencia documentada y repetible que investigar. Ambos resultados son útiles y ninguno exige adivinar.

Trata los conjuntos como la descripción de la persona que decidiste probar. No son una prueba de que un sitio lea o pondere los marcadores, y nada en el flag cambia eso.

Comprobar el resultado tras el lanzamiento

Después de lanzar con --bot-bookmarks, abre el gestor de marcadores y compáralo con el valor que pasaste:

const page = await browser.newPage();
await page.goto('chrome://bookmarks');

Una lista breve ayuda a que la comparación sea rigurosa:

1. Abre chrome://bookmarks y confirma que cada entrada de primer nivel de tu JSON está presente, y comprueba que el orden coincide con el que esperas.
2. Expande cada carpeta y confirma que el número de hijos coincide con el array children.
3. Revisa la propia barra de marcadores. Si los ajustes de la interfaz la ocultan, los marcadores pueden existir igualmente en el gestor.
4. Escribe en la barra de direcciones el dominio de una URL prellenada y mira si la lista de sugerencias muestra la entrada del marcador.
5. Anota el valor exacto de lanzamiento junto al resultado, para poder repetir la ejecución.

Si falta algo, los pasos de solución documentados son breves. Cuando los marcadores no aparecen, verifica que el JSON sea válido y que cada entrada tenga los campos title y type. Cuando una carpeta aparece vacía, asegúrate de que su array children contenga entradas válidas. Cuando el navegador informa de un error de análisis JSON, construye el valor con JSON.stringify() y no añadas comillas adicionales alrededor.

Límites y hábitos que conviene mantener

• Asocia los marcadores con la identidad del perfil. Un perfil alemán debería tener marcadores en alemán como google.de, spiegel.de y amazon.de.
• Varía los marcadores entre identidades. Cada identidad debería tener su propio conjunto, para que los resultados no se compartan por accidente entre identidades.
• Mantén un número revisable. Los conjuntos muy grandes son difíciles de auditar, y un conjunto vacío le quita sentido al prellenado.
• Mezcla categorías. Las personas guardan páginas de búsqueda, noticias, compras, redes sociales y trabajo. Un conjunto variado describe mejor una identidad que una sola categoría.
• Usa carpetas para organizar. Carpetas como Trabajo, Compras o Noticias son comunes y ejercitan el formato anidado.
• Fija las demás capas de forma explícita. Los marcadores funcionan junto con --bot-cookies, --bot-inject-random-history y los ajustes de configuración regional y zona horaria. Cada uno es su propio flag.

BotBrowser soporta el flag --bot-bookmarks, que llena el almacén de marcadores del navegador al lanzar a partir de un array JSON de entradas url y folder, para que puedas dar a cada sesión de prueba un estado de marcadores documentado y repetible sin una extensión. No puede garantizar cómo trata un sitio web o un sistema de seguimiento el estado de los marcadores, no reemplaza las cookies, el historial ni otras capas de identidad, y la persistencia más allá de la sesión depende de tu directorio de datos de usuario.

Preguntas sobre el prellenado de marcadores

¿Qué formato JSON acepta --bot-bookmarks?

El flag acepta un array JSON de objetos de marcador. Cada objeto tiene un title, un type ("url" o "folder") y un url para las entradas de URL o un array children para las carpetas. El JSON se pasa como cadena directamente en el argumento de línea de comandos.

¿Puedo cargar marcadores desde un archivo en lugar de JSON en línea?

La referencia de CLI documenta --bot-bookmarks como un flag que recibe una cadena JSON. Para conjuntos mayores, lee tu archivo de marcadores dentro del script de lanzamiento, valídalo y pasa el valor serializado como argumento.

¿Cuándo están disponibles los marcadores después del lanzamiento?

BotBrowser rellena el almacén de marcadores en el arranque a partir del valor que pasas. Abre chrome://bookmarks para confirmar el contenido.

¿Los marcadores persisten entre sesiones?

Según la documentación de Bookmark Seeding, los marcadores persisten durante la sesión y se guardan en el directorio de datos de usuario junto con otros datos de la sesión. Que algo pase a una sesión posterior depende, por tanto, del directorio de datos de usuario que uses. Da a cada identidad su propio directorio si quieres mantener separado su estado de marcadores.

¿Puedo usarlo con --bot-inject-random-history?

Sí. Los dos flags fijan capas distintas, marcadores e historial de navegación, y puedes pasarlos juntos en un mismo lanzamiento.

¿--bot-bookmarks requiere un tier específico?

La referencia de CLI lista --bot-bookmarks como un flag Core. Consulta la página de flags de CLI para ver la disponibilidad actual de cada flag.

¿Cuántos marcadores debería incluir?

Los suficientes para describir a la persona y pocos para revisarlos a mano. Entre diez y cincuenta entradas repartidas en algunas categorías es un rango práctico para una identidad de prueba. El número adecuado depende de lo que estés probando.

¿Prellenar marcadores cambia cómo los sitios web tratan la sesión?

No lo des por hecho. BotBrowser fija el estado de marcadores del navegador. No afirma que ningún sitio web o sistema de seguimiento lea o pondere ese estado, y la API chrome.bookmarks es una API de extensiones en la documentación de Chrome, no algo que use el JavaScript de las páginas.

Qué conviene recordar

Prellenar marcadores con --bot-bookmarks da a cada sesión de BotBrowser un estado de marcadores escrito, revisable y repetible. Combinado con cookies, historial de navegación y ajustes de configuración regional coherentes, mantiene bajo tu control una capa más de una identidad de prueba. Verifica el resultado en chrome://bookmarks, guarda el JSON en control de versiones y trata la función como una capa de estado entre varias.

Para temas relacionados, consulta Gestión de cookies para persistencia de sesión, Historial de navegación sintético para prellenado de historial, y Gestión de perfiles para organizar conjuntos de identidad completos.

Conclusión práctica

Usa el prellenado para hacer explícita y repetible una entrada del estado del navegador; comprueba el árbol visible y conserva solo los metadatos necesarios. BotBrowser controla la entrada de lanzamiento, no lo que cada sitio decide mostrar u observar.

Fuentes

• Chrome for Developers: referencia de la API chrome.bookmarks
• Documentación de BotBrowser: Bookmark Seeding