Las ejecuciones a las que un script no llega: tu sesión, tu navegador.
Donde el flujo ya está guionizado, Playwright hace el trabajo, y lo decimos en voz alta. Donde no lo está, un navegador vacío tiene que iniciar sesión primero: el staging de un cliente detrás de SSO, un estado al que llegaste a mano, la página en la que estás parado ahora mismo. Este ya está allí.
Conduce la persona. Qiksy percibe.
Todas las herramientas del tipo «la IA prueba tu aplicación por ti» naufragan en los mismos tres arrecifes. Qiksy los esquiva dejándote al volante, y ayudando en cada paso.
El problema del login desaparece
SSO, MFA y captchas matan a los agentes autónomos. Tú ya has iniciado sesión y ya estás en la pantalla correcta, así que Qiksy solo ayuda desde ahí.
Funciona al instante en cualquier sitio
Es una capa por encima, no una integración. Ábrelo sobre cualquier aplicación web, sea una herramienta interna, staging o producción, y funciona. Sin SDK, sin pipeline.
Honesto, no mágico
«A la IA no se le escapa ni un bug» es una promesa que se rompe en el primer despiste. «Te recuerda los casos límite y detecta fallos mientras pruebas» es una que sí cumplimos.
Cinco pasos, cada uno de un clic.
Este es el flujo entero, desde abrir una página hasta poner el arreglo en manos de un desarrollador o de un agente de IA.
Detección
Qiksy escanea cada formulario y muestra qué ha entendido de cada campo: etiqueta, tipo, restricciones. Transparencia en la que puedes confiar.
Relleno
Un clic coloca un escenario coherente: persona válida, valores límite (longitudes máximas, unicode), valores inválidos (formatos rotos, sonda XSS) o limpiar. No es basura de faker.
Captura
Mientras haces clic, los fallos van llegando: errores de consola, peticiones fallidas con el cuerpo de la respuesta del servidor y problemas de WCAG AA o de maquetación.
Copia
Cualquier hallazgo se copia como un informe de error listo para pegar, con selector, pasos para reproducirlo, captura y entorno adjuntos.
Entrega
Exporta la sesión entera para un agente de IA, o genera un recorrido en informe listo para el cliente. El ciclo de arreglos se cierra solo.
Una cabina de QA completa, en un panel lateral.
Todo gratis y todo activo desde el primer minuto, el grabador de sesión y los informes incluidos. Pro es una sola cosa: el puente hacia tu agente de código.
Relleno inteligente de formularios
Datos coherentes con la persona (correos que coinciden, confirmaciones de contraseña, opciones de país válidas) en campos nativos, en widgets ARIA personalizados como los selectores de fecha y los comboboxes de Radix o shadcn, e incluso en las subidas de archivo: una imagen o un documento neutro, elegido según lo que el campo acepta.
Hallazgos en vivo
Errores de consola, excepciones de JS, promesas rechazadas sin capturar y peticiones de red fallidas, capturados desde document_start, sin duplicados y filtrables por gravedad.
Auditoría de la página, WCAG AA
Controles sin etiqueta, botones sin nombre accesible, contrastes que no pasan, imágenes rotas, id duplicados, lang ausente, tabindex positivo. Y a través del puente del agente (1.6): el motor de reglas <b>axe-core</b> que va incluido, un recorrido con Tab que enumera lo que un usuario de teclado no alcanza nunca, y una comprobación de que los avisos emergentes se anuncian de verdad al lector de pantalla.
Vigilante del envío
Cruza el intento de envío con las peticiones fallidas, la validación nativa, aria-invalid y los avisos de error, y cuenta el mensaje real, no un simple «no válido».
Grabador de sesión
Una línea de tiempo que sobrevive a los cambios de página: cada visita con sus hallazgos, su registro de red y una miniatura. Exporta un bug, un HAR o un informe.
Roles y RBAC
Guarda la autenticación de un origen como un rol con nombre (cookies, incluidas las HttpOnly, localStorage y sessionStorage) y restáurala para probar admin frente a member frente a anónimo.
Lee los estilos, no solo la estructura
El color, la tipografía y el espaciado calculados, y las propiedades CSS personalizadas que hay en ámbito. Así «este botón se pinta en #3B82F6 a 15px» es un dato que puedes comparar con el diseño, no algo que hay que adivinar entornando los ojos sobre una captura.
Arsenal de valores límite
Haz clic derecho en cualquier campo y saca las cadenas maliciosas de BLNS, los nombres que rompen validaciones, los números frontera, las sondas de inyección y las tarjetas de prueba de Stripe. Cada campo ofrece lo que le corresponde.
Almacén de datos de prueba
Personas con nombre para cada sitio: aplícalas, edítalas como JSON, expórtalas e impórtalas para compartirlas con el equipo. Guarda los valores actuales de un formulario en un clic.
Archivos hostiles para los campos de subida
Adjunta un archivo de 0 bytes, uno de 12 MB, un PNG llamado .pdf, un nombre de 255 caracteres o un SVG que lleva un script dentro. Es la idea de las cadenas maliciosas aplicada al control que se rompe más a menudo.
Foco e inspección
Haz clic en cualquier hallazgo para oscurecer la página y remarcar el elemento. Elige cualquier elemento y llévate su selector, su rol ARIA, su nombre accesible y sus estilos.
Rellena cualquier widget
No solo campos de texto. Maneja comboboxes ARIA, selectores de fecha, interruptores, deslizadores, controles segmentados y editores de texto enriquecido como lo haría una persona, incluso campos controlados por React o dentro de un Shadow DOM, y dentro de modales, pestañas y acordeones.
Detecta lo lento, no solo lo roto
La maquetación que salta mientras carga, el botón que tarda un segundo en contestar, el tirón al abrir un menú: todo leído de las propias mediciones del navegador, con el elemento que se movió y el script que bloqueó el hilo. Con los umbrales de Core Web Vitals, así que un hallazgo de aquí coincide con Lighthouse.
Un solo archivo para el ticket
La sesión se convierte en un informe HTML autocontenido: pasos con capturas, hallazgos con selectores, peticiones fallidas con el cuerpo del error que devolvió el servidor. Dale los criterios de aceptación y tu veredicto sobre cada uno, y el informe empieza por ahí. Sin cuenta, sin enlace, sin subir nada: o lo adjuntas, o lo borras.
Mostrar, no contar
Pídele a tu agente un recorrido en lugar de un informe. Coge la pestaña que ya estás mirando, avanza por el flujo dentro de tu propia sesión ya autenticada y oscurece la página para remarcar cada elemento con su rótulo: paso 3 de 6. Una revisión que tu cliente ve suceder, y no unas capturas que tiene que creerse.
Prueba el error que el servidor no te va a dar
Haz que una petición responda como tú necesites: un 500, una lista vacía, una respuesta a la que le falta un campo, treinta segundos de nada, una conexión cortada. Los caminos de error son los que nadie comprueba, porque un backend que funciona se niega a romperse cuando se le pide, y «simular la primera llamada y dejar pasar el reintento» es la única forma de demostrar que el reintento reintenta. Una línea, ninguna carpeta que elegir, y sobrevive a una recarga. Tu agente puede ponerlo y quitarlo por su cuenta.
Su idioma, no solo el inglés
El panel habla siete idiomas (English, Deutsch, Español, Polski, Português, Русский, Українська) y toma el suyo del navegador en el primer arranque; un selector en el popup lo anula cuando la máquina está en un idioma y el equipo trabaja en otro. Los hallazgos y los informes de errores se quedan en inglés a propósito: se pegan en un gestor de incidencias que lee gente de otro país.
Una prueba, no solo hallazgos
Toda la página en una imagen, por larga que sea, con flechas, recuadros y textos grabados dentro del archivo. O la pantalla en un MP4 que se abre en cualquier sitio, con tu voz. No se guarda nada: vive mientras está en pantalla.
El formulario que rellenas veinte veces por semana
Rellénalo a mano una vez, con Qiksy mirando. A partir de ahí es una pulsación: los mismos valores, la misma ruta, los mismos pasos del asistente, y una parada allí donde una persona tendría que mirar de todos modos.
Grábalo tal y como trabajas
Pulsa Grabar y rellena el formulario como lo harías siempre: a mano, con ⚡ Fill o de las dos formas. Pulsa Parar y ponle nombre. No hace falta cambiar nada de tu manera de trabajar.
Repetirlo es una pulsación
Los valores vuelven a los campos de los que salieron y el Siguiente del paso se pulsa solo. Si aparece un campo que la página ya no tiene, la ejecución se detiene y el veredicto NOMBRA ese campo: un «listo» en verde sobre un formulario a medias es peor que un fallo claro.
Sigue la ruta que recorriste
Un flujo rara vez cabe en una página: el siguiente paso del asistente, el paso por el inicio de sesión, una página de pago en otro dominio. La repetición sigue la misma ruta en la misma pestaña, y en cada frontera de página espera tu Continuar, porque una página recién cargada no es sitio para escribir sin permiso.
El mismo flujo con otros datos
{ } abre los datos de la ejecución como una lista sencilla de campos: cambia un correo, una fecha, el nombre de una empresa; 🎲 los vuelve a rellenar con valores nuevos y verosímiles. Una sola grabación cubre así un pase de regresión, y a un campo de subida puedes darle un archivo tuyo.
Las contraseñas no están dentro
Las contraseñas y los números de tarjeta se graban como campos, nunca como valores, porque un escenario es un archivo que se exporta y se envía. La repetición se detiene ahí y te pide que lo escribas tú; y a un escenario importado se le quitan, antes de la primera ejecución, todas las direcciones que salen de su propio sitio.
El informe es el trabajo. Lo demás es cómo llegar a él.
Nadie retiene ocho hallazgos hasta el final del día, así que no se anotan: acaban en un chat como capturas y media frase. Aquí el documento se llena en el momento en que algo se nota: una línea con tus palabras, un trozo recortado de la página, un hallazgo con lo que pasó y lo que debía pasar. Al final, una pulsación, y sale una página HTML autónoma que se imprime en PDF.
Cuesta un gesto, no una tarde
Una idea llega mientras clicas por la aplicación, y cuesta un campo y Enter. Ocho ideas, ocho pulsaciones. Esa es toda la diferencia entre un informe escrito mientras se trabaja y otro montado de memoria por la tarde.
La imagen es prueba, no adorno
Sin ella no se construye el documento. Una página de afirmaciones sobre una aplicación que no muestra ninguna es justo lo que esta herramienta sustituye. Y el nombre de una captura no se reparte dos veces: bajo un hallazgo nunca puede aparecer la imagen de otro momento.
Nada queda grabado a fuego
Flechas, texto y recorte se guardan como DATOS junto a la imagen limpia: mueve la flecha mañana y cambiará con ella cada informe que nombre esa captura. El documento se reconstruye desde sus propios bloques, así que corregir una palabra no obliga a rehacerlo entero.
Sigue ahí una hora después
Los informes terminados se quedan en la extensión con un nombre: ábrelo, imprímelo, guárdalo o úsalo como forma del siguiente. Y cuando el navegador se queda sin sitio lo dice y conserva tu trabajo, en vez de tirarlo sin avisar.
Dos manos, un informe
Y esto no lo tiene nada más en esta página. El mismo borrador es accesible para tu agente a través del puente: qa_draft lee las líneas, qa_draft_add escribe una, qa_draft_edit la reescribe, qa_draft_build lo convierte en documento. Tú fotografías el total roto y el agente escribe el hallazgo debajo. O él reúne las pruebas mientras sigues probando y tú afinas la redacción al final. No son dos informes que luego hay que cuadrar, sino un montón y dos manos.
Una llamada en vez de noventa y cinco
El mismo formulario de 94 campos, rellenado dos veces, y ambos lados hablan MCP, que es como tu agente conduce un navegador de verdad. Qiksy gasta una llamada. Playwright MCP gasta noventa y cinco.
Aquí nada está ralentizado ni acelerado. Los dos controladores son servidores MCP reales y ambos actúan sobre el mismo navegador y la misma pestaña: qiksy-mcp por su WebSocket local y @playwright/mcp conectado por CDP, que es la versión generosa para él, porque por su cuenta primero levanta un navegador vacío. La página se cronometra sola, de la primera tecla al envío, y el banco de pruebas está en el repositorio: puedes ejecutarlo tú.
Y la parte honesta, porque lo vas a medir igualmente. Frente a un script de Playwright escrito de antemano perdemos: eso es código dentro de tu propio proceso de pruebas, sin agente y sin protocolo, y rellena este formulario en unos 0,4 s. Esa comparación era la que estaba en esta página hasta hoy, y era la equivocada: una biblioteca no es un puente. Frente a Playwright MCP, que es lo que un agente tiene realmente en la mano, los números de arriba son la mediana de tres ejecuciones. Una cosa más que no ocultamos: Playwright MCP también tiene un verbo por lotes, browser_fill_form, y con él el mismo formulario entra en unos 0,7 s en dos llamadas, pero esa lista de noventa y cuatro campos y sus tipos la tiene que construir el agente. El nuestro toma un diccionario simple etiqueta → valor y resuelve el resto solo, y sigue siendo una llamada tenga el formulario diez campos o doscientos.
La velocidad es la mitad pequeña. La grande es en el navegador de quién se ejecuta.
Tu agente ya sabe abrir una URL: es una línea de shell, y aterriza en el navegador en el que tienes la sesión iniciada. Lo que no sabe es mirar lo que se ha abierto, si la página cargó, si sigues dentro, qué dice el error. Playwright sí sabe mirar, pero solo dentro de un navegador que ha lanzado él, con un perfil en blanco en el que nunca has entrado. Entre esas dos mitades es donde todo el mundo elige.
| Cómo se abre la página | De quién es el navegador | El agente ve la página | El agente actúa en ella |
|---|---|---|---|
open <url>, shell a secas | El tuyo, con la sesión ya iniciada | No | No |
| CDP / Playwright | El suyo, un perfil en blanco | Sí | Sí |
| Qiksy | El tuyo, con la sesión ya iniciada | Sí | Sí |
Qiksy es la fila que tiene las dos cosas. Nunca lanza un navegador y nunca te quita la ventana: trabaja dentro de la pestaña que ya tienes abierta, y por eso la sesión que lee es la de verdad, con tus roles, tus permisos, el entorno de staging detrás del SSO y la cuenta de cliente que en un perfil recién hecho no puedes recrear.
Un panel. Todos los movimientos de QA.
Formularios, hallazgos, auditorías, roles, cobertura y el historial completo de la sesión en una sola cabina que se maneja con el teclado. Oscura o clara, con el acento que quieras; el rayo dorado siempre se queda como firma.
Entrega todo el contexto de QA a tu agente de código.
Un servidor MCP neutral respecto al proveedor permite a Claude Code, Cursor, Cline, Windsurf, Zed o VS Code leer el estado de QA en vivo directamente del navegador: hallazgos con selectores CSS, formularios detectados, peticiones fallidas con el cuerpo de la respuesta del servidor, pasos de reproducción grabados. Di «arregla lo que Qiksy ha encontrado en esta página» y el agente ya lo tiene todo. También puede manejar las superficies propias de Qiksy, como abrir el panel, lanzar la auditoría, sacar la lista de cobertura o generar el informe, y, en cuanto activas Agent control, también la aplicación que estás probando. Desactivado por defecto: al volante sigues tú hasta que decidas otra cosa.
npx qiksy-mcp📦 Published on npm · npmjs.com/package/qiksy-mcp →Todo lo que tu agente puede hacer dentro del navegador que ya tienes abierto.
Sin un segundo navegador, sin volver a entrar, sin perder la sesión. Leer es gratis y no pide permiso; actuar es un interruptor que activas tú.
Lo que ve
Gratis · sin consentimiento- La página como un árbolCada control, cada región y cada encabezado con su rol, su nombre y su estado, y una referencia estable sobre la que actuar.
- Geometría realCada caja en píxeles CSS. Así es como dice «cortado», «se solapa», «un objetivo táctil de 28px» sin una sola captura.
- Estilos y tokens de diseñoEl estilo calculado, y de qué token salió cada color.
--accent, no solorgb(37,99,235). - Qué se rompió de verdadErrores de consola y de JS, peticiones fallidas con el cuerpo del error del servidor, velocidad y saltos de la maquetación.
- El almacenamiento de la aplicaciónlocalStorage y sessionStorage: feature flags, estado en caché, el token de sesión.
- Accesibilidad de verdadEl motor axe-core completo dentro de la página en vivo, más el recorrido del teclado hecho Tab a Tab.
- Una imagen de toda la páginaDe arriba abajo, por larga que sea: la desplaza, la fotografía pantalla a pantalla y la une. Las contraseñas y los campos de tarjeta se tapan antes.
- Una tabla, no una páginaNombra las filas y las columnas, cada artículo con su precio, cada campo con lo que contiene ahora, y eso es una respuesta en vez de una docena de lecturas.
- Qué pasa despuésObserva unos segundos, así que un aviso que aparece y se va, una petición lanzada por un temporizador o un anuncio para lectores de pantalla no se pierden. Cada observación caduca sola.
- Buscar dentro de una capturaCada palabra de la página queda escrita de forma invisible sobre sus propios píxeles, así que Ctrl+F funciona en la imagen. No es reconocimiento: el texto nunca se perdió.
Lo que hace
Pro · Agent control- Rellena cualquier formularioUn paso entero de un asistente en una sola llamada: le pasas los valores en JSON y él resuelve las etiquetas solo.
- Todo tipo de widgetAnt, MUI, Radix, react-select, downshift: desplegables, calendarios, cascadas, árboles, etiquetas, horas, cada uno con su propio verbo.
- Hace clic, escribe y responde con el diffQué apareció, qué cambió, qué acaba de abrir el clic, así que nunca tiene que adivinar si funcionó.
- Entra por Microsoft, Google u OktaEs tu navegador: normalmente ya tienes la sesión iniciada, y la pestaña que abre el proveedor se suma a la sesión por su cuenta.
- Varios logins a la vezUn tarro de cookies por pestaña, un solo navegador, sin un segundo perfil: admin, member y anónimo, uno al lado del otro.
- Sube archivos de verdadPor su ruta en tu máquina, todos los adjuntos de un paso de una vez, y los bytes nunca entran en el contexto del agente.
- Navega y esperaVa a una ruta y espera a que la página se asiente antes del siguiente movimiento. Solo dentro de las pestañas que hayas conectado.
Lo que muestra y recuerda
Para ti, no para el registro- Te pone la pestaña delanteLevanta la ventana y remarca el elemento del que habla: un recorrido que pasa donde estás mirando.
- Recuerda un formulario largoGuarda el flujo como una receta indexada por el nombre de cada campo y la repite en la sesión siguiente: una llamada por paso en lugar de una exploración.
- Te entrega el artefactoUn informe HTML autocontenido: primero tus criterios de aceptación, y debajo de cada uno las pruebas.
- Una prueba que puedes adjuntarToda la página en una imagen, con tus flechas y textos grabados dentro, o la pantalla grabada en un MP4 que se abre en cualquier sitio, con tu voz.
- Una grabación que se leeEl vídeo llega con los momentos de la página: clics por su nombre, peticiones fallidas con la respuesta del servidor, lo que oyó un lector de pantalla. Pulsa uno y salta ahí.
Ninguna captura de pantalla. Tiene mediciones, no una imagen, así que «¿se ve bien?» es una pregunta para tus ojos. Ningún JavaScript arbitrario. Es una regla de la Chrome Web Store, y la razón de que cada comando nombre un elemento y nunca un programa. Todo lo demás ocurre en el navegador en el que ya tienes la sesión iniciada.
| Herramienta | Qué devuelve |
|---|---|
qa_tabs | Todas las pestañas que Qiksy puede leer, incluidas las que son sesiones multi-login aisladas, así que un agente puede comparar qué ve cada uno: admin, member y anónimo. |
qa_status | La URL + los recuentos de errores / avisos / formularios + el nombre del login aislado. tabId opcional. |
qa_findings | Hallazgos con selectores y detalle; filtra por severity (all / error / warning). |
qa_export | El paquete qa-export/v1 completo: hallazgos, peticiones fallidas con sus cuerpos, estructura de los formularios, pasos de reproducción, entorno y un mapa de navegación (rutas con nombre a las que el agente puede ir llamándolas por él). |
qa_open_panel | Comando. Abrir o cerrar el panel de Qiksy e ir a una pestaña (findings / tour / history …). |
qa_run_audit | Comando. Pasar la auditoría de accesibilidad y maquetación sobre el DOM actual y devolver los hallazgos. |
qa_axe | Comando. Pasar el motor axe-core que va incluido, el mismo que hay debajo de Lighthouse, sobre el DOM en vivo: cientos de reglas WCAG A/AA, cada infracción con su impacto, sus etiquetas WCAG y los selectores culpables. Todo local: de la página no sale nada. |
qa_focus_walk | Agent control. Recorrer la página Tab a Tab y contar el recorrido REAL del teclado: lo que un usuario de teclado no alcanza nunca, las trampas de foco sospechosas y los saltos de foco que pelean con la disposición de la página. |
qa_tour | Comando. La lista de pruebas exploratorias, material de cobertura para escribir casos de prueba. |
qa_report | Comando. Generar el informe HTML autocontenido de la sesión y devolverlo. |
qa_spotlight | Comando. Oscurecer la página y remarcar un elemento por su selector, para que veas de qué habla el agente. |
qa_focus_tab | Comando. Trae una pestaña delante de ti, la activa y levanta su ventana, para que el recorrido pase donde estás mirando. Limitado a la aplicación bajo prueba y a sus logins; es para «muéstrame», no para comodidad del agente. |
qa_tabs le da a cada uno su nombre de isolatedSession y su tabId, y qa_export por pestaña compara qué ve cada uno, admin, member y anónimo. El agente además actúa dentro de cada login: el mismo tabId va a qa_fill_json y a qa_click, así que trabaja como ese usuario sin un segundo navegador y sin volver a entrar. La lista completa de herramientas está en el README de qiksy-mcp.- En el popup de la extensión, abre MCP bridge, ponlo en On, pulsa Generate para obtener un token, elige un puerto (por defecto 7333) y pulsa Save.
- Registra el servidor en tu editor con el mismo token y el mismo puerto. El token se pasa en la variable de entorno
QIKSY_MCP_TOKEN.
El servidor es un único paquete npx. Todos los editores usan el mismo comando; solo cambian el archivo donde vive y un par de claves. Elige el tuyo abajo y pega.
alarms despierta al service worker dormido para que se reconecte. No hace falta tocar el manifest ni la CSP para ws://127.0.0.1.# run in your project
claude mcp add --transport stdio qiksy \
--env QIKSY_MCP_TOKEN=YOUR_TOKEN \
-- npx qiksy-mcp --port 7333{ "mcpServers": { "qiksy": {
"command": "npx",
"args": ["qiksy-mcp", "--port", "7333"],
"env": { "QIKSY_MCP_TOKEN": "YOUR_TOKEN" }
} } }{ "context_servers": { "qiksy": {
"source": "custom",
"command": "npx",
"args": ["qiksy-mcp", "--port", "7333"],
"env": { "QIKSY_MCP_TOKEN": "YOUR_TOKEN" }
} } }{ "servers": { "qiksy": {
"type": "stdio",
"command": "npx",
"args": ["qiksy-mcp", "--port", "7333"],
"env": { "QIKSY_MCP_TOKEN": "YOUR_TOKEN" }
} } }Conéctalo a tu agente en un solo pegado
El puente habla MCP, así que cualquier agente capaz (Claude Code, Cursor, Cline, Windsurf, Zed, VS Code) puede leer el estado de QA en vivo y, con Agent control activado, actuar dentro de la sesión que ya tienes abierta.
Full documentation
Install, the panel, isolated logins, the MCP bridge and all twenty-two tools, agent control, troubleshooting.
Read the docs →Referencia de herramientas
Las veintidós herramientas con sus parámetros y sus respuestas, los tres candados y la configuración para cada editor.
Read on npm →Instrucciones para el agente
El prompt completo para copiar y pegar: cómo arrancar una pasada, la única regla que mantiene fiables los recorridos de varias páginas y qué cosas el agente no debe fingir que sabe hacer.
Read on npm →You are setting up the Qiksy manual-QA Chrome extension so you can drive the
human's REAL, logged-in browser: over Qiksy's MCP bridge, and (optionally) over
Playwright/CDP for direct clicks. Go ONE STEP AT A TIME. After each step, ask the
human to confirm what they see before continuing. Whenever you send them to a panel
or popup, FIRST DRAW AN ASCII DIAGRAM of it with the exact control marked "← click".
USE GOOGLE CHROME. Qiksy is a Chrome extension, not Firefox, Safari or Edge. Do
everything in Google Chrome (a Chromium build works, but tell the human to use
Chrome unless they know otherwise).
TWO FACTS THAT MAKE OR BREAK IT, state them up front:
1. The Chrome window must stay OPEN and LOGGED IN to the app under test for the
whole session. The bridge and Playwright both attach to that live window; close
it and the session is gone.
2. To load an UNPACKED (dev) build, the human must be LOGGED IN first, because a fresh/
incognito profile has no session. Log in, THEN load, and keep that window.
STEP 1 · extension
Install Qiksy from the Chrome Web Store, or chrome://extensions → Load unpacked →
the dist folder. Confirm the round Q bubble shows bottom-right on any page.
STEP 2 · the token (DRAW THIS)
Open the toolbar popup and find "Agent bridge · MCP":
+-- Qiksy popup --------------------+
| Assistant overlay [ On ] |
| Agent bridge · MCP [ On ] | <- turn ON, accept the consent
| Port [ 7333 ] Token [________] |
| [ Generate ] [ Copy ] | <- Generate, then Copy (it saves itself)
+-----------------------------------+
Have them Generate -> Copy (the popup saves it automatically), and paste the token to you.
STEP 3 · run the bridge (keep it running in a terminal)
QIKSY_MCP_TOKEN=<paste the token> npx qiksy-mcp --port 7333
STEP 4 · connect you (MCP)
Add the qiksy server to the agent config (Claude Code: claude mcp add --transport
stdio qiksy --env QIKSY_MCP_TOKEN=<token> -- npx qiksy-mcp --port 7333; or the
.mcp.json block from the site). Restart the agent, then call qa_tabs, which should list
the human's tabs. If it says "not connected", the popup bridge is off or the token/
port differ.
STEP 5 · drop the manual into the project
Run "npx qiksy-mcp init" in the project root. It writes the full agent guide to
.claude/qiksy-bridge.md and adds a short block to CLAUDE.md / AGENTS.md, so every
future session starts knowing what the bridge can do.
STEP 6 · Playwright over CDP (optional, and only for two things)
Qiksy drives the browser itself: clicks, whole forms, calendars, uploads, several
logins. The only gaps are SCREENSHOTS and arbitrary JavaScript. If the task needs one
of those, launch Chrome with --remote-debugging-port=9222 (or reuse the open window),
keep it OPEN and LOGGED IN, and point Playwright MCP at http://localhost:9222.
THEN: qa_tabs -> qa_export (forms with MEANING + live findings) -> drive with
qa_fill_json (a whole step per call) and qa_click by name (needs Pro + "Agent control"
on in the panel). A control that refuses is a ladder, not a wall: qa_probe, raw:true,
qa_pick_*, a CSS selector, and never a second browser driver, which would open an empty
browser without these logins. You cannot undo: a click on a real Delete deletes for
real. If a tool says pro-required or consent-required, name the switch the human must
flip, and stop.You have Qiksy over MCP: a manual-QA extension attached to a REAL Chrome window
with the human's logins already in place. It IS the browser for this session: do not
switch to Playwright, Puppeteer, Selenium or CDP because a control looked unfamiliar
or refused once. Another driver opens a DIFFERENT, EMPTY browser, and none of these
logins are in it, so the run stops being the test that was asked for. Exactly ONE
thing is absent here: arbitrary JavaScript (no eval, a Web Store rule, which is why
every verb names an element, never a program). Screenshots ARE here now
(qa_screenshot), with one condition: the browser photographs the window's ACTIVE tab,
so a background tab cannot be photographed and Qiksy refuses rather than handing over
a page nobody asked about. Need eval? Say so, and let the human decide.
Start with:
qa_tabs · which tabs are in the agent session, which are isolated logins
(every tool takes tabId)
qa_snapshot · the page as an accessibility tree with stable refs; fields_only on a
heavy app, geometry:true for every box in CSS pixels
qa_export · forms with MEANING (kind: "email" / "card-number" / "first-name"),
findings, failed requests WITH the server's error body, repro steps
and a NAVIGATION map (labelled routes, current:true on the open page)
Don't scrape the DOM yourself, because qa_export already knows what each field is and where
the app can go. Pick a route from navigation[] and go by href instead of probe-clicking.
A FORM IS ONE CALL PER STEP, never one per field (needs Pro + "Agent control"):
qa_fill_json { fields: { "Full name": "Ada Lovelace", "Country": "Ukraine",
"Start date": "06/11/2024", "I agree": true },
advance: "Next" }
It resolves the labels itself, drives custom dropdowns, calendars, cascaders, trees,
tags and time pickers, and presses Next ONLY if every entry landed. Keys that matched
nothing come back with the page's real field names, so your next call fixes itself.
WHEN A CONTROL REFUSES, the ladder, in order. Don't change tool, change rung:
qa_probe { name } what this widget is and which verb drives it
raw: true write the value straight into its own text input
qa_pick_date / _time / _range / _path (cascader, tree) / _tags
a CSS selector every verb takes one; a portalled popup with no roles
(Ant) is MEANT to be driven that way
qa_click { name } then read the "widget" verdict in the reply and act on it
qa_focus_tab custom popovers only render in the FOREGROUND tab
AFTER ANYTHING THAT NAVIGATES call qa_wait_ready, and press the advance control by
NAME, not by a ref you took before filling: any new snapshot renumbers refs, so an old
one succeeds on the WRONG control. This is the most common way a run goes wrong.
Several logins at once:
qa_open_isolated { url, sessions: ["admin","member"] } → one cookie jar per tab
qa_close_tab { tabIds: [...] } → clean up
SSO works with Microsoft, Google and Okta: it is their own browser, and a tab the provider
opens joins the session automatically. A captcha or a 2FA prompt is theirs: stop and say so.
Saw a long form? qa_recipe_save { name }, and the next run replays it a call per step.
Finish with qa_report { path, spec: { title, story, checks:[{id,text,status,evidence}] } }
It is a self-contained HTML file led by YOUR verdicts next to Qiksy's evidence.
You cannot undo. A click on a real Delete button deletes for real. If a tool says
pro-required / consent-required, that is a switch the human must flip: say which
one and stop.Herramientas avanzadas para trabajo real con clientes.
Más allá del panel del día a día, Qiksy trae instrumentos más pesados (grabación, informes, RBAC y entrega al desarrollador) para que una sesión de pruebas se convierta en algo que puedes facturar y con lo que un desarrollador puede ponerse a trabajar.
Informes listos para el cliente
Un clic convierte la sesión en un recorrido autocontenido: capturas con el elemento resaltado, pasos de reproducción numerados, mosaicos de cobertura y de defectos. El artefacto que le entregas a un cliente; no hace falta ningún backend.
Grabador de sesión y HAR
Una línea de tiempo que atraviesa las navegaciones, con miniaturas y el registro de red de cada paso. Exporta un informe de error completo y reproducible, o un HAR sin cabeceras, sin nada sensible que limpiar.
Roles y multi-login
Guarda la autenticación como roles con nombre y luego ejecuta admin, member y anónimo en pestañas distintas de un mismo navegador. Prueba el RBAC en minutos, sin entrar y salir de las cuentas.
Bug Capsule
Empaqueta un error en una única página reproducible, con la captura del elemento, la cola de la consola, las peticiones fallidas, el selector y el entorno, para que el desarrollador lo reproduzca a la primera.
Modo seguimiento
Usa la aplicación y ya está: Qiksy mira tus clics y marca los errores, los clics muertos, los clics de rabia y las respuestas lentas, cada uno clavado a la acción exacta y listo para pegar como informe de error.
Entrega al agente
Dale el paquete qa-export/v1 en bruto a tu agente de código. Claude Code, Cursor o cualquier cliente MCP lee tus hallazgos, la estructura de los formularios y las peticiones fallidas directamente del navegador y los arregla.
Todo esto es gratis y seguirá siéndolo: relleno de formularios, hallazgos, auditorías, el Tour, multi-login, la grabación de sesiones, las cápsulas de error y el informe para el cliente. Pro es una sola cosa: el puente MCP, el enlace por el que tu agente de código lee este navegador y lo conduce. Cada instalación recibe 28 días de puente, sin tarjeta.
Hace pareja con MultiLogin Tabs.
Los roles y el multi-login de Qiksy manejan varias cuentas dentro de una misma sesión de pruebas, sobre el mismísimo motor de aislamiento que MultiLogin Tabs. Cuando lo que necesitas es que cada pestaña del navegador tenga una cuenta distinta, todo el día, coge la extensión completa.
'/%3e%3c!--%20Shield%20shape%20representing%20isolation/protection%20--%3e%3cpath%20d='M64%2022%20L98%2038%20L98%2062%20C98%2084%2082%20100%2064%20108%20C46%20100%2030%2084%2030%2062%20L30%2038%20Z'%20fill='none'%20stroke='white'%20stroke-width='4'%20stroke-linejoin='round'%20opacity='0.95'/%3e%3c!--%20Two%20separated%20tab%20rectangles%20inside%20shield%20--%3e%3crect%20x='44'%20y='48'%20width='16'%20height='20'%20rx='3'%20fill='white'%20opacity='0.9'/%3e%3crect%20x='68'%20y='48'%20width='16'%20height='20'%20rx='3'%20fill='white'%20opacity='0.9'/%3e%3c!--%20Divider%20line%20between%20tabs%20--%3e%3cline%20x1='64'%20y1='44'%20x2='64'%20y2='74'%20stroke='%236366f1'%20stroke-width='2.5'%20stroke-dasharray='3,3'/%3e%3c!--%20Small%20lock%20icon%20at%20top%20of%20shield%20--%3e%3crect%20x='58'%20y='33'%20width='12'%20height='9'%20rx='2'%20fill='white'%20opacity='0.9'/%3e%3cpath%20d='M61%2033%20L61%2029%20C61%2026%2063%2024%2064%2024%20C65%2024%2067%2026%2067%2029%20L67%2033'%20fill='none'%20stroke='white'%20stroke-width='2'%20stroke-linecap='round'%20opacity='0.9'/%3e%3c/svg%3e)
MultiLogin Tabs Extensión complementaria
Usa varias cuentas del mismo sitio en una sola ventana del navegador, sin incógnito y sin perfiles aparte. Asigna cada pestaña a una sesión con nombre y tendrá su propio entorno totalmente aislado.
Prueba más rápido. Informa mejor.
Instala Qiksy, abre la aplicación que estés probando y pulsa Fill. Desde ahí sigue Qiksy.
Añadir a Chrome, gratisManifest V3 · tus datos se quedan en tu equipo · sin telemetría
¿Quieres que tu agente de código trabaje también? Consigue una licencia de 1 año por 49 USD