Skip to main content
L3gitUI · API · MOBILE TEST AUTOMATION
[ PRODUCT ][ PRICING ][ DOCS ][ VERIFIED ][ REGULATED ][ COMPARE ][ ACCOUNT ] Start Free Trial
CODE YOU OWN · RUNS IN YOUR CI · OFFLINE READY
// 14-DAY FREE TRIAL · NO CARD REQUIRED

TEST AUTOMATION SOFTWARE THAT WRITES REAL SELENIUM AND REST ASSURED TESTS.
GENERATED IN MINUTES, OWNED FOREVER.

>> Point and click to build UI, API and Android app tests — L3git writes a standard Maven project that's yours. No scripting background needed.
>> Run it at any volume in your own CI for $0. No proprietary runtime, no per-run fees, no lock-in.

Generates & runs on the tools you already use

Selenium Cucumber REST Assured Appium JUnit 5 Maven Jenkins GitHub Actions
New in 1.2 L3git Mobile — record on a real Android phone, get an Appium + Cucumber project you own; self-healing locators and a Section 508 audit of every screen. Buy it alone ($79), pair it, or get it in the Suite. What's new →

Also recent: parallel runs without a Selenium Grid · Section 508 audit of every page · local AI via Ollama · Model-Eval beta for AI-model regression.

FROM CLICK TO CI IN HOURS

NO CODE · NO SCRIPTING · NO WAITING

Point & click

Click through a live website, or build a REST / GraphQL / SOAP request in the API editor. No code, no locator hunting, no scripting background needed.

Generate a project

One click writes a complete Maven project for you — feature files, step definitions, page objects, pom, runner, even a Jenkinsfile. In seconds.

Commit & run anywhere

Push to git and mvn test in any CI. The code is yours — it runs with or without our app, forever.

SEE IT WORK

RECORD · GENERATE · OWN · RUN
  1. 01

    Record or build — no code

    Click through a live site to capture a UI flow, or build a REST / GraphQL / SOAP / WebSocket / Kafka / gRPC request in the API editor. Name things in plain English.

  2. 02

    Generate a real project

    One click writes a complete Maven project — feature files, step definitions, page objects, pom, runner, even a Jenkinsfile and a GitHub Actions workflow.

  3. 03

    Own the code outright

    The output is standard Cucumber, Selenium, and REST Assured — no proprietary format, no runtime of ours. It compiles and runs whether or not you keep our app.

  4. 04

    Run anywhere, for free

    Push to git and mvn test in any CI — at any volume, in parallel — with no per-run fee. Publish results to Allure, Slack, TestRail, or Xray if you like.

L3git — recording
https://app.example.com/login
Email
qa@example.com
Password
••••••••
Log in
RECORDED STEPS
type email
click Log in
RECORD GENERATE RUN

A faithful recreation of the record → generate → run flow — the generated output runs in your own CI with mvn test.

WHAT'S IN THE BOX

ONE TOOL · UI + API + MOBILE

Browser Recorder L3git UI

Point-and-click UI test recording on Edge, Chrome, or Firefox — with self-healing locators that repair themselves when the page changes.

  • Clicks, typing, dropdowns, keyboard, waits
  • 12 built-in assertions + conditional branches
  • Responsive: mobile / tablet / desktop
  • In-app runner + local HTML report

API Testing L3git API

A browser-free desktop suite that folds functional, performance, and security API testing into one tool — and outputs owned REST Assured code.

  • REST / GraphQL / SOAP · OAuth2 · chaining
  • Load testing: flows, ramp-up, SLA gates
  • Service virtualization + fault injection
  • Security scan mapped to the OWASP API Top 10
  • Secrets file + run-a-local-file token — never in your code
  • Organize, set run order, disable, run all / in parallel

Android Recorder L3git Mobile NEW

Record on a real phone or emulator with a live preview, and get an Appium + Cucumber project that runs on your own devices and agents — offline.

  • Taps, typing, swipes, checks — locators you can swap
  • Self-healing + local-AI repair
  • Section 508 audit of every screen
  • Hybrid apps (WebView) · Jenkins shards × devices

All Three + Bridge L3git Suite

UI, API and Mobile in one license, plus the end-to-end test only UI + API together can build: log in through the browser, then hit the backend as that user — one scenario.

  • Everything in UI + API + Mobile
  • Cookie bridge: browser session → API
  • Combine UI + API steps in one project
  • One unified workspace

WHY L3GIT

THE SMALL-TEAM ADVANTAGE

You own the code

Pure Java, Cucumber, Selenium, and REST Assured — no proprietary format. Stop subscribing and keep 100% of your tests forever.

No CI execution tax

Run your tests 10 or 10,000 times a day in your own CI for $0. No parallel-runner fees, no cloud minutes, ever.

Offline & air-gapped

A native Windows desktop app that runs fully local — your APIs, tokens, and code never touch our servers. It drives the Edge your IT already installed and never downloads a browser; air-gapped builds bundle the matching WebDriver. A standard key re-checks licensing briefly at each launch and rides out a 14-day outage; for no-internet sites we issue an offline key that makes zero outbound calls. Ideal for finance, health, and gov.

Replace Selenium Grid with your own agents — or keep a grid

No Grid needed: L3git writes a Jenkins Matrix pipeline — shards × browsers — so the suite fans out across your own agents, each on its installed browser, split deterministically by stable scenario ids. How to move off the Grid → Prefer a grid or cloud? Run the same suite on a Selenium Grid or a cloud vendor — BrowserStack, Sauce Labs, LambdaTest — and fan out across Chrome, Firefox, Edge, and Safari plus OS versions. No code change; just point grid.url at the hub. Credentials stay in env vars, never in the repo.

Section 508, every page NEW

One checkbox audits every page your tests visit against the Section 508 + WCAG 2.0 A/AA rule sets with bundled axe-core — fully offline, no cloud service. Each page is attached to its scenario in the report and a standalone Section 508 compliance chapter is written on every run. Report-only, or fail the build. The per-page A11y step is still there for targeted checks.

AI authoring & repair INCLUDED · BYO KEY OR LOCAL NEW

Describe a test in plain English and the AI drafts the steps from the live page; when a step breaks, one click proposes a new locator. Authoring-time only — your generated tests stay 100% deterministic and never call an API. Bring your own Anthropic key — no token markup — or point it at a local open model via Ollama so nothing leaves your PC. When it proposes a fix, it outlines the element on the page and tells you where it found it (nav vs footer), so you never take its word for it; with hard daily & monthly usage caps built in.

Also in the box

  • Git & CI ready — Generated projects ship with a pom, runner, Jenkinsfile, and GitHub Actions workflow.
  • No log4j — enforced — One checkbox adds a Maven Enforcer ban to the generated build, so it fails loudly if log4j ever slips into the dependency tree — a supply-chain guarantee your security team can verify.
  • Visual regression — Snapshot a page or element and diff it against a committed baseline on every run — an owned pixel-diff with tolerance controls and a highlighted diff image.
  • Plugs into your stack — Push results to Jira/Xray and TestRail, alert Slack or Teams, and open rich Allure reports — plus the standard JUnit XML your CI already reads. Proof →
  • Run only what changed — Test-impact analysis maps every test to the URLs and endpoints it touches, so a pull request runs just the affected slice instead of the whole suite — from one git diff.
  • Beyond REST — Test event-driven and streaming systems too: WebSocket, Kafka (produce/consume), and gRPC (dynamic calls via server reflection — no .proto needed). Proof →
  • Contract testing (Pact) — Generate consumer-driven contracts with Pact straight from your API steps — the consumer side runs fully local (Pact's own mock provider, no infra) and writes the contract to target/pacts.

EDITIONS AT A GLANCE

UI · API · MOBILE · SUITE
Capability UI API Suite
Point-and-click browser recorder✓—✓
Self-healing locators✓—✓
Responsive (mobile / tablet / desktop)✓—✓
Section 508 audit of every page + compliance report NEW✓—✓
Per-page accessibility step (axe-core · WCAG)✓—✓
Visual regression (pixel diff) ADVANCED✓—✓
REST / GraphQL / SOAP · OAuth2 · chaining—✓✓
Load testing (flows · ramp · SLA gates)—✓✓
Service virtualization + fault injection—✓✓
Security scanning (OWASP API Top 10)—✓✓
Secrets file + run-a-local-file token step—✓✓
Folders · run order · disable · run page—✓✓
Postman / OpenAPI / Swagger import—✓✓
AI authoring & repair — your own key or a local model via Ollama NEW✓✓✓
Reporting & integrations (Allure · Slack/Teams · TestRail · Xray)✓✓✓
Smart test selection (test-impact analysis)✓✓✓
Non-REST protocols (WebSocket · Kafka · gRPC)—✓✓
Data-driven (CSV) + parallel execution✓✓✓
Generates git/CI-ready Maven project✓✓✓
Drives the IT-installed Edge; air-gapped builds bundle the WebDriver NEW✓—✓
AI pick shown on the page (element, region, HTML) before you accept NEW✓—✓
Stable @l3id scenario ids (survive renames; flake-ready) NEW✓✓✓
UI + API cookie bridge (one scenario)——✓
Android mobile recorder → Appium project, self-healing, 508 audit of every screen NEW 1.2——✓ (or Mobile alone)
Own the code · offline · 14-day trial✓✓✓

Every edition generates standard code you own and runs in any Maven / Jenkins / GitHub Actions / GitLab pipeline — with no per-run fee.

HOW WE COMPARE TO OTHER TEST AUTOMATION TOOLS

THE FOUR KINDS OF TOOL →
UI testing · vs Katalon
$588 vs ~$1,699–2,040

per user per year — about a third of the price for the same browser coverage, and the generated Selenium is yours.

UI + API · vs Katalon + ReadyAPI
$2,028 vs ~$5k–13k+

per user per year — a 2.5–6× saving per seat, with the UI-to-API bridge the two-tool stack can't build.

Mobile · vs Katalon / Kobiton / cloud grids
$948 + $0 per run

per user per year on your own phones and agents — no metered device minutes, no runtime engine, Appium code you own.

Every edition: ✓ own your code   ✓ no per-run fee   ✓ offline — most alternatives miss at least two of the three.

Full head-to-head tables →

Competitor prices are public list prices for market context and may change.

SIMPLE PER-SEAT PRICING

BILLED ANNUALLY · 14-DAY FREE TRIAL

One price per user. No hidden execution taxes, no proprietary runtime, no cloud lock-in. Buy just the tool you need — UI, API or Mobile — pair any two, or take the Suite. Add another tool later and pay only the difference.

Launch offer 10% off any plan — auto-applied at checkout with code LAUNCH10.
L3git UI
$49 / user / mo
Billed annually — $588 / user / yr

The point-and-click browser recorder for UI & frontend automation teams.

  • [x] Self-healing UI recorder (Edge / Chrome / Firefox)
  • [x] Accessibility (axe/WCAG) + visual regression
  • [x] Smart test selection + reporting integrations (new)
  • [x] Generates git/CI-ready Cucumber + Selenium
Buy — $49 / user / mo or start a 14-day free trial
L3git API
$129 / user / mo
Billed annually — $1,548 / user / yr

The browser-free API suite for API, performance & security engineers.

  • [x] REST / GraphQL / SOAP + WebSocket · Kafka · gRPC (new)
  • [x] Load testing · service virtualization · security scan
  • [x] Reporting: Allure · Slack/Teams · TestRail · Xray (new)
  • [x] Generates git/CI-ready REST Assured you own
Buy — $129 / user / mo or start a 14-day free trial
New in 1.2
L3git Mobile
$79 / user / mo
Billed annually — $948 / user / yr

The Android app recorder for mobile QA teams. iOS follows.

  • [x] Record on a real phone with a live preview; self-healing locators
  • [x] Section 508 audit of every screen + local-AI repair
  • [x] Bundled Appium — air-gapped, no Node on the PC
  • [x] Generates git/CI-ready Appium + Cucumber you own
Buy — $79 / user / mo or start a 14-day free trial
Best Value
L3git Suite
$219 / user / mo
Billed annually — $2,628 / user / yr

UI + API + Mobile, plus the UI + API bridge. Every recorder, one license. For full-stack SDETs & QA architects.

  • [x] Every UI feature (a11y · visual regression)
  • [x] Every API feature (load · virtualization · security · protocols)
  • [x] Every Mobile feature (Android recorder · 508 audit) (new)
  • [x] UI + API cookie bridge in one scenario
  • [x] Reporting + test-management integrations (new)
Buy — $219 / user / mo or start a 14-day free trial

Need two? Pair them.

EACH PAIR COSTS LESS THAN THE TWO BOUGHT APART
UI + API
$169/ user / mo
$2,028 / yr · $178 bought apart

Browser + backend, plus the UI-to-API bridge: log in through the browser, call the API as that same user, one scenario.

Buy — $169 / user / mo
UI + Mobile
$109/ user / mo
$1,308 / yr · $128 bought apart

Web and Android in one recorder: the same step language, the same owned code, one Jenkins matrix.

Buy — $109 / user / mo
API + Mobile
$179/ user / mo
$2,148 / yr · $208 bought apart

Backend and app testing without a browser recorder — for teams whose web front end is someone else's problem.

Buy — $179 / user / mo

Already a customer and want another tool? Open your billing portal from your account, switch to the plan that includes it, and you are charged only the prorated difference. A new key covering both tools is emailed to you within a minute — paste it on the Activation tab.

Only UI + API together can test the handoff. Log in through the browser, then call the API as that same authenticated user — one scenario, one session, no fixture faking the token. Buying UI and API as two separate seats gives you both halves and not the seam between them, which is where real bugs live.

The UI + API pair ($169) and the Suite ($219, adds Mobile) both include the bridge.

Team & volume pricing

SAME PERCENTAGE OFF EVERY PLAN · TYPE THE CODE AT CHECKOUT
1–4 seats
List price
LAUNCH10 applies itself
5–9 seats
8% off · code TEAM8
Suite $201 · Mobile $73 / user / mo
10–24 seats
15% off · code TEAM15
Suite $186 · Mobile $67 / user / mo

One invoice, a key for every seat; add seats anytime at your tier's rate. Example: 10 Suite seats with TEAM15 = $186/user/mo ($22,320/yr), $3,960 saved.

25+ seats? Talk to us

Floating seats

+$99 / mo flat

Turn your seats into a shared concurrent pool. A seat frees the instant someone closes L3git, so a team — or a shared CI box — rotates through fewer seats. Flat add-on, any pool size.

Add floating to your plan

Air-gapped / offline

+$149 / mo flat

An offline signed license, verified locally and never contacts the internet — for locked-down, regulated, or air-gapped networks. No online check-in, ever.

Request an offline license

These two are alternatives — pick one. Floating leases seats online; Air-gapped never contacts the internet, so they can't be combined on one key.

FAQ

STRAIGHT ANSWERS

Q. Do I really own the generated tests?

Yes. Output is standard Java, Cucumber, Selenium, and REST Assured in a normal Maven project. It compiles and runs with no app of ours involved — if you ever cancel, you keep every test forever.

Q. Are there per-run or CI charges?

Never. You pay per seat for the desktop tool. Executing the generated tests in your own CI — at any volume, in parallel — is free.

Q. Does it work offline?

Your tests, APIs, and code stay on your machine — we never receive them. On licensing: a standard online key re-checks the license server briefly each time the app starts, and keeps working for a 14-day grace period if that server is unreachable. Floating seats also check in about every five minutes to hold the lease. For a fully air-gapped environment we issue an offline key that makes no outbound calls of any kind — not even the update check. Full detail on our security page.

Q. What do I need to run the output?

JDK 17+ and Maven. The generated project includes a Jenkinsfile and a GitHub Actions workflow, so mvn test runs locally or in CI on the next push.

Q. What do I need to install?

Just the download. The desktop app runs on the PowerShell that already ships with Windows — no Python, Node, or extra runtime to install, which suits locked-down and air-gapped machines. (Running the generated tests needs JDK 17+ and Maven, like any Java project.)

Q. Which edition should I pick?

UI for browser testing, API for backend/performance/security, Suite for both plus the UI + API bridge. Suite is cheaper than buying UI and API separately.

Q. Does the AI cost extra to run?

AI authoring is included in every edition — you just bring your own API key. It helps you author and repair tests in the app for typically pennies per action, with built-in daily and monthly caps so it can't run away, and no markup from us. Your generated tests never call the AI, so running them in CI stays free and fully deterministic. Prefer zero AI? Just don't add a key — nothing else changes.

Q. How does the free trial work?

Download it and launch it — the 14-day trial starts on first launch. There's no key to request and no card to enter, and every feature is unlocked. A license key is only needed to keep going after day 14.