> ## Documentation Index
> Fetch the complete documentation index at: https://docs.testsprite.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Overview
> AI-powered front-end testing for web apps. Explore your app, generate plans grounded in real behavior, ship browser tests, watch them run, replay any step.
UI Testing in TestSprite is a journey from "here's my web app" to "here's a regression suite that catches UI bugs without breaking on every minor refactor". This page is the map.
## Key Features
| Feature | Description |
| :------------------------------------- | :---------------------------------------------------------------------------------------------------------- |
| Fast Setup | Get started in minutes — share your URL and (optionally) a test account |
| Feature Exploration (Beta) | TestSprite explores your live app feature by feature so the test plan reflects real behavior, not docs |
| AI-Generated Test Cases | Test plans tailored to your real screens and flows; full control to add, remove, or refine |
| Step-by-Step Replay | Every run records a video + per-step screenshots — replay to see what happened visually |
| Live Test Preview | Watch tests run in real time and catch issues as they happen |
| Auto-Heal (Pro) | When the UI drifts, TestSprite re-decides selectors against the live DOM instead of marking the test Failed |
| Natural Language Refinement | Adjust any test in natural language — no code required |
| Reusable Test Code | Generated Python + Playwright tests, ready to drop into CI/CD or regression suites |
## The UI Testing Journey
```mermaid theme={null}
flowchart LR
A[1. Feature Exploration
walk the live app
feature by feature]
B[2. Plan Generation
test cases grounded
in observed flows]
C[3. Test Generation
Python + Playwright
per test case]
D[4. Run + Step-by-Step
watch live, replay later]
E[5. Rerun
re-execute on demand
or on a schedule]
F[6. Auto-Heal Pro
absorb UI drift on
subsequent runs]
A --> B --> C --> D --> E --> F
```
Each step gets its own page. Click through in order if you're new — or jump to the one giving you trouble.
How TestSprite walks your live app to discover what to test
Review the plan grounded in observed flows; edit, add, prune
Python + Playwright code per test case
Per-step screenshots, video, and behavior trace for one test
Project-level video gallery — every recording, bucketed by status
Re-execute a single test, the whole project, or a scheduled run
Recover UI tests when the page changed but the flow is fine
## What Lives Where
The Web Portal sidebar for a UI project is grouped into Overview / Data / Result. UI projects don't have integration chains, shared-value wiring, or cleanup phases, so the sidebar is shorter than a backend project's
| Group | Item | What you see |
| :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Overview | Use Case Flow | Site map of explored features; click a node to drill in |
| Overview | Integration Testsdefault | Flat list of UI test cases with status chips and last-run results — clicking a row opens its detail page (recorded video, step-by-step screenshots, error trace, refine + rerun) |
| Data | Site Exploration | Per-feature exploration walks: what TestSprite reached, where it got stuck |
| Data | Authentication | Test account credentials used during exploration and runs |
| Result | Agent Actions | Project-level video gallery of every test recording, bucketed by status — see [Agent Actions](/web-portal/core/ui/agent-actions) |
| Result | Test Report | Aggregated outcomes; badges show Failed (red) and Blocked (amber) counts |
Settings actions at the bottom of the sidebar: **Export to Github**, **Delete Creation**.
Test list scheduling (paid; auto-heal toggle) lives under the global **Monitoring → Schedules** section, not the per-project sidebar.
**UI testing is single-test-centric, not chain-centric.** Each UI test is end-to-end self-contained — sign in, do the thing, assert. There's no cross-test data wiring like there is in backend tests. The complexity in UI testing is on the per-test side (the page, timing, change absorption) not the multi-test orchestration side.
## Quick Start
Walk through your first UI project end-to-end — from project creation to a passing browser test — in about 10 minutes.
## Refining Tests in Natural Language
Every test row supports natural-language refinement. You can say:
```text Refine theme={null}
Original: "Test login functionality"
Refined: "Verify the Sign In link directs users to the login page and that valid credentials land them on the dashboard."
```
```text Add theme={null}
Add a test that signs up a new user with an invalid email and confirms the inline validation appears.
```
```text Edit theme={null}
For the Checkout test, drop the assertion that the URL contains '/success' — our flow uses '/order/{id}' instead.
```
TestSprite parses the request, regenerates affected test code, and re-runs. See [Refining Tests](/web-portal/core/working-with-test/refining-tests) for the full chat capabilities.
## Backend's Sibling Page
If you're testing an HTTP API rather than a website (UI / browser flows), the backend equivalent of this page is [API Testing — Overview](/web-portal/core/api/api-testing). The wizard, refinement, and rerun concepts mirror; the underlying execution model differs (HTTP requests vs. browser actions), and a few features are exclusive to one side:
| | UI Testing | API Testing |
| :----------------- | :-------------------------------------------------- | :------------------------------------------------------------ |
| Discovery phase | Feature Exploration (TestSprite walks the live app) | API Discovery (reads your docs and confirms endpoint shapes) |
| Plan grounding | Observed flows | Observed responses |
| Test execution | Browser via Playwright | HTTP via requests |
| Multi-step concept | Each test is end-to-end | Integration chains across endpoints |
| Drift handling | [Auto-Heal](/web-portal/core/ui/auto-heal) on rerun | (No equivalent — APIs don't drift the same way) |
| Auth handling | Static test account | [Auto-Auth](/web-portal/core/api/auto-auth) for token refresh |
## Where to Go Next
The first phase — walk the live app
See exactly what happened on each step of a run
Absorb UI drift between runs without re-writing tests
Free includes 10-feature exploration; Pro unlocks unlimited + Auto-Heal