Documentation

Quick start

Flow types

Each flow is a sequence of steps. Available step types:

• navigate: go to a URL
• click: click an element by selector
• fill: type text into an input
• assert: verify an element exists on the page
• api: make an HTTP request (for setup, auth, cleanup, or status assertions). Shares cookies with the browser session.

Each step supports optional timeout (custom wait time) and wait after (pause after execution).

Testing authenticated flows

Many critical flows (dashboard, settings, checkout) require a logged-in user. Use an API step as the first step in your flow to log in via your app's API. Cookies are shared with the browser, so subsequent steps run as an authenticated user.

Example: test the dashboard behind login

Step 1  api       POST /api/auth/login
                   Headers: {"Content-Type": "application/json"}
                   Body:    {"email": "test@example.com", "password": "testpass123"}
                   Assert:  status:200

Step 2  navigate  /dashboard
Step 3  assert    h1:has-text("Welcome")
Step 4  click     a:has-text("Settings")
Step 5  assert    form.settings-form

The API step makes a real HTTP request using Playwright's request context. The session cookie from the login response is automatically used by all following browser steps: no manual cookie handling needed.

Tip: create a dedicated test user in your staging environment so tests don't interfere with real data.

Import Playwright tests

If you already have a Playwright test file, paste its contents into Import on the project page. Each test(...) block becomes a flow.

Actions the parser recognizes

• page.goto(url) → navigate
• page.click(selector), getByRole, getByText → click
• page.fill(selector, value), getByPlaceholder, getByLabel → fill
• expect(locator).toBeVisible() → assert
• request.get/post/put/delete(url, options) → api step (with headers, body, and status assert)

Example: paste, get structured flows

import { test, expect } from '@playwright/test';

test('Login flow', async ({ page }) => {
  await page.goto('https://app.example.com/login');
  await page.fill("input[name='email']",
    'test@example.com');
  await page.fill("input[name='password']", 'pw');
  await page.click("button[type='submit']");
  await expect(page.locator('h1')).toBeVisible();
});

test('API health check', async ({ request }) => {
  const res = await request.get(
    'https://api.example.com/health');
  expect(res.status()).toBe(200);
});

Complex patterns (loops, helper functions, fixtures, variables in selectors) are skipped with a warning, not a hard failure.

AI features

• AI Generate: crawls your real site, extracts DOM elements, and suggests 3-6 flows with working CSS selectors
• Natural language flows: type what to test (e.g. "check footer links") and AI creates a single flow by crawling your site
• Explain with AI: click on any failed step to get an AI explanation of the root cause and what to fix
• Smart locator healing: when a selector breaks, AI analyzes the page and suggests a better selector
• Flaky detection: automatically identifies steps that pass sometimes and fail others, with severity badges on flow cards

Example: AI Generate output

Scheduled runs

Set up automatic regression runs on a schedule:

• Daily: runs every day at your chosen time
• Weekly: runs on a specific day and time

Configure in the project page under Schedule. Times are in your local timezone.

CI/CD integration

Trigger runs from your deployment pipeline using your API key:

curl -X POST https://regresco.com/api/webhook/trigger \
     -H "x-api-key: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"projectId": "your-project-id"}'

Generate your API key in Settings → API Keys. See Settings → Webhook Config for full examples (GitHub Actions, GitLab CI, Vercel, bash).

Auto-heal

When a step's selector breaks (classes rename, IDs change, elements move), Regresco doesn't just fail. The runner looks at the current DOM, finds a plausible replacement for the same element, and retries the step with the new selector. If it passes, the step is marked as Auto-healed instead of Failed.

You see auto-heal signals at four levels:

• Projects list & Runs list: a small green dot next to the run status tells you at a glance the run had drifting selectors.
• Flow card on the project page: an N auto-healed badge next to the flow name.
• Run detail: each healed step gets an Auto-healed badge; hover shows the selector that actually worked.
• Edit Flow: a green hint appears below the selector input with the healed value and an Apply button that replaces the brittle selector in one click.

Auto-heal is reactive, not predictive. Every healed selector is a signal that the underlying UI changed. Use the Apply button in Edit Flow so the next run doesn't have to re-discover it.

Example: healed selector in Edit Flow

Failure classification

Every failed step is automatically classified:

• Likely regression: the page loaded but behavior changed from the baseline
• Broken locator: the element wasn't found, likely due to a UI change
• Flaky: intermittent failure, not consistently reproducible

Failed steps are automatically retried once before being marked as failed. Failing elements are highlighted with a red outline in screenshots.

Example: classified failure with fix hint

Baseline comparison

Each run is automatically compared to the previous completed run:

• New failures: steps that passed before but now fail
• Fixed: steps that were failing but now pass
• Still failing: steps that continue to fail

Example: run compared to baseline

Artifacts

Every run produces:

• Screenshots: captured after navigate, click, and fill steps
• Playwright traces: replay locally with npx playwright show-trace trace.zip
• Flow history: stability trend per flow across runs

Jira integration

Every failed step in a run can auto-create a Jira issue so your QA team doesn't file tickets by hand.

Setup

1. On a project page, open the Jira button in the topbar.
2. Enter your Atlassian URL (https://yourcompany.atlassian.net), email, and an API token generated at id.atlassian.com/manage-profile/security/api-tokens.
3. Enter the project key (short uppercase identifier like QA) and issue type (defaults to Bug; team-managed projects often only have Task).
4. Click Test connection to verify. It should say "Connected as {name}".
5. Toggle Enable and save.

What lands in Jira

On a FAILED run, each failed step becomes an issue with:

• Title: [Project] Flow: step N (action) failed
• Bullet list with project, flow, step, classification
• Error message as a code block
• Healer hint (if the auto-heal couldn't fix it)
• Link to the screenshot and a direct link back to the run in Regresco

The API token is stored encrypted (AES-256-GCM). Disable the integration at any time without losing the saved credentials.

Example: what an auto-created issue looks like

Email notifications

Get notified when runs complete. Emails include status, passed/failed count, and a link to the run dashboard.

Toggle on/off in Settings → Profile → Notifications.

Reliability features

• Auto cookie banner dismissal: automatically closes common consent popups
• Scroll into view: elements below the fold are scrolled into view before interaction
• Adaptive timeouts: timeout adjusts based on page load speed (3x first navigate time)
• Retry on failure: transient failures are retried once before marking as failed
• Parallel execution: up to 3 flows run concurrently per test run
• Click fallback: hidden elements (dropdown items) are clicked with force as fallback

Plans

Free plan: 5 runs per month, 1 project. Pro plan ($49/month): 200 runs, 20 projects. Business plan ($149/month): 1000 runs, 100 projects, priority queue. All features are available on every plan. Upgrade any time from Settings → Profile.

Need help?

Reach out at hi@regresco.com or use our contact form.