Record · Replay · Regression-proof

QA that works
like you do.

Use your app normally. Skopix records every action. AI stabilises the selectors, writes the Playwright code, and replays it all — deterministically — every time.

Get started free → See how it works View on GitHub
skopix dashboard
$ SKOPIX_SECRET_KEY="..." skopix dashboard --team
✔ Dashboard running at http://localhost:9000
✔ Team mode active · 3 users online
── Replaying: Create A Bar Chart ──────────────────
[1/14] CLICK — Click username input field
[2/14] TYPE — Type 'admin' into username field
[5/14] CLICK — Click the plus icon to add chart
[13/14] ASSERT — Chart is visible
[14/14] ASSERT — Title attribute contains "Bar chart"
✔ PASSED · 14 steps · 9.4s

Record once.
Replay forever.

No scripting. No selectors. Just use your app — Skopix captures everything and turns it into a stable, repeatable test.

01 — RECORD
Use your app normally
Click Record in the dashboard. A real Chrome window opens. Use your app exactly as a user would — click, type, navigate, scroll. Every action is captured in real time. Add assertions by clicking "+ Assert" in the floating toolbar — pick any element, choose what to check (text, visibility, count, attribute), done.
No code required
02 — AI PROCESSING
AI stabilises your steps
After you stop, Skopix sends your raw steps through an LLM. It rewrites fragile positional selectors into stable ones (data-testid, aria-label, semantic HTML). It generates human-readable descriptions for each step. It produces complete Playwright test code in both JavaScript and TypeScript — ready to drop into your CI pipeline.
Gemini · OpenAI · Ollama
03 — REPLAY
Run it whenever you want
Click replay from All Tests, run a suite in parallel, or trigger from CI. Skopix replays every step deterministically in a headed browser. Smart click disambiguation matches elements by their recorded coordinates when multiple match. Failed steps stop the test and tell you exactly which step and why.
Deterministic · No flakiness
04 — DEBUG
Fix tests at any step
Click the ⏺ button on any step to set a debug point. Skopix replays up to that step automatically — navigating, logging in, filling forms — then hands control back to you in the browser. Record new steps from exactly that state. New steps get AI-processed and inserted back into your test.
No re-recording from scratch
05 — REUSE
Share setup flows
Mark any test as Reusable. Other tests can reference it as their Setup — Skopix runs the setup steps first in the same browser session, then hands off to the main test. Record your login flow once. Every other test that needs authentication just references it. No duplication, no maintenance headache.
Setup · Teardown · Reuse
06 — REPORT
📋
Full session reports
Every replay generates a full report: two-column layout with video on the left, clickable step list on the right. Click any step to see the screenshot at that point. Sessions are stored in All Sessions. Suite runs aggregate results across all tests. Audit log tracks who ran what and when.
Video · Screenshots · HTML report

Assert anything.
Without writing code.

During recording, click "+ Assert" in the toolbar, pick any element on the page, and choose what to verify. Smart auto-suggestion picks the most appropriate type based on the element.

VISIBLE
Element is present and visible on screen
TEXT CONTAINS
Element's text content includes a substring
TEXT EQUALS
Element's text matches exactly
URL CONTAINS
Current page URL includes a path or query string
ELEMENT COUNT
Exactly N elements match the selector
ATTRIBUTE CONTAINS
title, alt, aria-label, data-* attribute includes value
GENERATED PLAYWRIGHT CODE
// Assert chart renders
await expect(page.locator('.highcharts-container')).toBeVisible();
// Assert top value is correct
await expect(page.locator("span:has-text('60.00')")).toContainText('60.00');
// Assert tooltip explains SVG behaviour
await expect(page.locator('i.fa-question')).toHaveAttribute('title', /SVG equivalent/);

Bring your own AI.
Or run it locally.

Skopix uses AI at one point only — processing your raw recording into stable selectors and Playwright code. Replay is fully deterministic, no LLM involved. Choose whatever fits your setup.

Google Gemini
gemini-2.5-flash (default)
Fast, affordable, excellent at code generation. The recommended default. Free tier available via Google AI Studio. Set GEMINI_API_KEY in config.
OpenAI
gpt-4o-mini · gpt-4o
Reliable choice if you already have OpenAI credits. gpt-4o-mini is the cost-effective option. Set OPENAI_API_KEY in config.
🖥 Ollama (local)
llama3.1 · qwen2.5-coder · any model
Run AI completely on your machine. No API key, no cost, no data leaving your network. Ideal for air-gapped environments or privacy-sensitive codebases. Requires Ollama running locally.
CONFIGURE VIA skopix init OR .skopix.env
# Gemini (default)
SKOPIX_PROVIDER=gemini
GEMINI_API_KEY=AIza...
# OpenAI
SKOPIX_PROVIDER=openai
OPENAI_API_KEY=sk-...
# Ollama (local)
SKOPIX_PROVIDER=ollama
OLLAMA_MODEL=llama3.1
OLLAMA_BASE_URL=http://localhost:11434
💡 Privacy note: AI is only called when you finish a recording. Your test steps (selectors, values, URLs) are sent to the LLM to generate stable selectors and Playwright code. During replay, zero AI calls are made — it's pure deterministic browser automation. If you use Ollama, nothing ever leaves your machine.

Solo or as a team.
Same install.

One flag changes everything. Run locally for personal use, or flip to team mode and share with your entire QA team — no separate server software needed.

⬡ SOLO MODE
Just you
Run the dashboard on your machine. Open at localhost:9000. No authentication, no accounts. Perfect for personal projects, freelance work, or trying Skopix out.
$ npm install -g skopix
$ skopix init
$ skopix dashboard
→ Open http://localhost:9000
⬡ TEAM MODE
You and your team
Adds login, user accounts, roles (Admin/Tester/Viewer), audit log, and shared test libraries. Teammates connect via your IP or a tunnel like Portix. All test data lives on the host machine.
SKOPIX_SECRET_KEY="long-random-string" \
skopix dashboard --team --host 0.0.0.0
→ Visit /setup to create the first admin
→ Invite teammates from the Users tab
SHARING WITH REMOTE TEAMMATES
Same office
Teammates connect at http://your-ip:9000 on the same Wi-Fi. Find your IP with ipconfig getifaddr en0.
Remote · Portix tunnel
Run portix 9000 --name skopix for an instant public URL. Teammates open it from anywhere.
Always-on · Dedicated machine
Leave a Mac or Linux desktop running as a shared server. Recording needs a real display — Docker/cloud VMs won't work for that.

Up in under
a minute.

1. INSTALL
$ npm install -g skopix
$ npx playwright install chromium
→ Installs the Skopix CLI and Chromium browser on your machine
2. CONFIGURE YOUR AI PROVIDER
$ skopix init
→ Choose your provider: gemini / openai / ollama
→ Enter your API key (or skip for Ollama)
→ Settings saved to ~/.skopix.env
3A. SOLO MODE — JUST YOU
$ skopix dashboard
→ Open http://localhost:9000 in your browser
→ Click "Record test" to start your first recording
3B. TEAM MODE — ONE COMMAND STARTS EVERYTHING
# Add these to ~/.skopix.env once:
SKOPIX_SECRET_KEY=your-shared-secret
SKOPIX_AGENT_EMAIL=your@email.com
SKOPIX_AGENT_PASSWORD=yourpassword
# Then just run:
$ skopix start
→ Starts the dashboard in team mode
→ Starts and authenticates the agent on your machine automatically
→ Teammates connect via http://YOUR-IP:9000
3C. TEAMMATES — CONNECT AS AN AGENT
# Each teammate runs this on their own machine:
$ npm install -g skopix
$ npx playwright install chromium
$ skopix agent --server http://HOST-IP:9000 --key "your-secret"
→ Prompts for Skopix dashboard login to identify your machine
→ Chrome opens on YOUR machine when you trigger tests
→ Leave it running in a terminal while you work
USING OLLAMA (LOCAL AI — NO API KEY NEEDED)
# Install Ollama from https://ollama.ai, then:
$ ollama pull llama3.1
# In ~/.skopix.env or via My Settings in the dashboard:
SKOPIX_PROVIDER=ollama
OLLAMA_MODEL=llama3.1
→ AI runs entirely on your machine. No data leaves. No cost.
HOW IT ALL FITS TOGETHER
1 person hosts
Runs skopix dashboard --team and keeps it running. Everyone connects to their machine.
Everyone runs an agent
Runs skopix agent in a terminal. Their browser opens locally when they trigger a recording or replay.
Tests run on your machine
When you click Record or Replay, Skopix dispatches to your agent. Chrome opens on your screen. Results stream back to the shared dashboard.
⚠ AGENT IS REQUIRED TO RECORD AND REPLAY
In team mode, the agent must be running on your machine before you can record or replay tests. The dashboard alone cannot open a browser — the agent is what does the browser work locally. Always start your agent before using the dashboard.
BACKUP YOUR TESTS
# All your tests, suites, sessions and credentials live in one place:
→ ~/.skopix/
# Back up everything to a zip on your Desktop:
$ node skopix-backup.js
→ Creates skopix-backup-2026-05-26.zip on your Desktop
# Restore on any machine (auto-finds the zip on Desktop/Downloads):
$ node skopix-restore.js
→ Restores all tests, suites, sessions and credentials
→ Restart Skopix after restoring
DOWNLOAD BACKUP SCRIPTS
Get skopix-backup.js and skopix-restore.js from the GitHub repo. On Mac, double-click .command wrappers to run without opening a terminal.

Questions.

Do I need to write any code? +
No. You use your app, Skopix records it. The AI generates Playwright code automatically after each recording — you can download the .spec.js or .spec.ts file if you want to run it in CI directly. But you never have to write a selector or a test script yourself.
How is this different from Playwright's own recorder? +
Playwright's recorder generates raw selectors as-is — often fragile positional ones. Skopix uses an LLM to stabilise those selectors into semantic, stable equivalents. It also adds a full dashboard, team mode, setup/teardown flows, debug recording, credential management, suite running, and session history with video. It's a complete QA platform, not just a code generator.
What if a selector breaks after a UI change? +
Open the step editor (✏ on any test), find the failing step, and update the selector directly. Or use the ⏺ debug button on that step — Skopix replays everything up to that point in a real browser, then lets you record the correct action from scratch. New steps are AI-processed and inserted automatically.
How does the login/setup flow work? +
Record your login flow once and mark it as Reusable. In any other test's editor, set that login test as the Setup. When that test runs, Skopix runs the login steps first in the same browser session — so the test starts already authenticated. No duplicating login steps across every test.
Can I store credentials securely? +
Yes. Go to Credentials in the dashboard, create a named credential set (e.g. panintelligence) with username and password. Attach it to a test via the step editor. During replay, Skopix substitutes the stored password into any isPassword: true step — so the real password is never stored in the test YAML, and teammates with different credentials can run the same test.
Can I use Ollama or a local LLM? +
Yes. Install Ollama, pull any model (ollama pull llama3.1 or ollama pull qwen2.5-coder), then set SKOPIX_PROVIDER=ollama and OLLAMA_MODEL=llama3.1 in your .skopix.env. AI runs entirely on your machine — no data leaves, no API costs, works offline. Note: smaller models may produce less stable selectors than Gemini or GPT-4o.
How do remote teammates connect? +
Same office: connect at http://your-ip:9000 on the same network. Remote: run portix 9000 --name skopix (using Portix) for an instant public URL — teammates open it from anywhere. Always-on: deploy to a cloud VM with Docker (~£4/mo at Hetzner), point your domain at it, done.
Can I run tests in CI? +
Yes — download the generated Playwright code. Every recording produces a .spec.js and .spec.ts file you can grab from the "View code" button on any test. Drop those into your existing Playwright CI setup and run with npx playwright test. That's the recommended CI path — the generated code is clean, stable, and has no Skopix dependency.
Does replay open a real browser? +
Yes — Skopix opens a real headed Chrome window for recording and replay. This means it needs to run on a machine with a display (your Mac, Windows PC, or Linux desktop). Docker containers don't work for recording or replay because they have no display. The recommended setup is to run Skopix on one team member's machine and have everyone else connect via their browser — no installation required on their end.
How do I update Skopix? +
npm install -g skopix@latest then restart the dashboard. Docker: docker compose pull && docker compose up -d. Your test data in ~/.skopix/ (or the mounted volume) is never touched during updates.
Start recording.
Stop scripting.

Free. Self-hosted. Your tests, your data, your machine. One command to get started.

Install now → GitHub Share with Portix