Automate any web app with the same syntax you already know — locating elements by what the user sees, not brittle CSS or XPath. Built-in waits, visual testing, native desktop-app support, and an AI-native agent for the SPAs that break everything else.
Feature: Login and Dashboard
Scenario: User logs in and sees dashboard
Given driver 'https://app.example.com/login'
# locate by visible text — survives redesigns
And input('#email', 'user@test.com')
And input('#password', 'secure123')
When click('{^}Sign In')
# Verify dashboard loaded
Then waitFor('.dashboard')
And match text('.welcome') contains 'Hello'
# Take a screenshot for visual testing
And screenshot()Grows with you
Browser and desktop automation in the open-source framework is free forever. Paid tiers add developer productivity and the AI-native agent for enterprise SPAs — never gates on the basics.
Open Source
Cross-browser automation with display-text locators, built-in waits, visual testing, parallel execution, and native desktop-app support — MIT licensed, free forever.
Free
Get it on GitHub →IDE Pro
IntelliJ & VS Code plugins with syntax highlighting, run-from-IDE, debugging, and autocomplete — plus the Xplorer desktop client for authoring.
$640/seat/yr
See plans →Enterprise
Karate Agent for AI-native browser automation that self-heals across enterprise SPAs, plus self-hosted deployment with support.
Custom
Explore Karate Enterprise →The end of locator hell
Selenium, Playwright, and Cypress bind tests to CSS and XPath selectors — so a redesign that changes an id shatters the suite. Karate locates elements by what the user sees, and Karate Agent adapts on its own when the page moves.
await page.fill('#email-input-v2', val);
await page.click(
'button[data-testid="submit-v2"]');
await page.waitForSelector(
'.dashboard-welcome');
// Ship a redesign — this fails.* input('{^}Email', val)
* click('{button}Sign In')
* waitFor('{^}Welcome')
# locate by visible text —
# no id, no XPath to break.* agent { url: '/login' }
* agent.do('sign in as admin')
* agent.verify(
'dashboard shows Welcome')
// Ship the same redesign —
// this still passes.Free open source already beats brittle selectors. Karate Agent takes it to full self-healing.
Karate Agent
Karate Agent drives the browser with an LLM — authoring tests in plain English, recovering when the UI drifts, and reading the DOM directly instead of pixel screenshots. It runs the SPAs that brittle tools can't touch, entirely inside your network.
Where it sits
Classic frameworks are deterministic but brittle. Cloud computer-use agents adapt but live in someone else's cloud with a token bill per run. Karate Agent is the only one that's both adaptive and deterministic, self-hosted, and audit-grade.
| Selenium / Playwright / Cypress | Cloud computer-use (Claude, OpenAI) |
Karate Agent | |
|---|---|---|---|
| Locator approach | CSS / XPath selectors | Pixel screenshots | Display-text + DOM |
| Adapts when the UI changes | No — breaks | Yes | Yes — self-heals |
| Deployment | Self-hosted | Vendor cloud | Self-hosted, air-gap |
| LLM choice | — | Single vendor | Any LLM (BYO) |
| Cost to re-run in CI | Free, high maintenance | Token bill per run | ~$0 deterministic replay |
| Audit evidence | Screenshots only | Model's say-so | Video + screenshots |
Built for the hardest DOMs
Guidewire, Salesforce, and ServiceNow generate deep, shifting DOMs that recorder-based tools can't keep up with. Karate Agent reads structure and intent — so it drives them reliably, run after run.
Built for what matters
The two things that decide whether a UI suite survives a real release schedule — and where teams move to Karate from brittle, high-maintenance tools.
Velocity
Self-healing locators kill the maintenance tax that eats UI suites. Regression that took two weeks compresses toward two nights — and stable flows replay deterministically at ~$0, so shipping stops waiting on QA.
Trust
Karate runs locally — no data leaves your network, zero telemetry, ever. The framework is MIT-licensed and auditable, every Agent run leaves video evidence, and stable checks are deterministic, so a green build means the same thing every time.
Open-source foundation
The free framework underneath the agent: reliable by design — no flaky selectors, no manual waits, no maintenance nightmares.
Run the same tests across Chrome, Firefox, Safari, and Edge. Powered by the WebDriver protocol and a Playwright-compatible driver, with zero config changes.
Built-in screenshot comparison for visual regression testing. Catch layout shifts and styling bugs before they reach production.
Find elements by the text a user actually sees — {button}Sign In — instead of CSS or XPath that breaks on every redesign.
Automate Windows and macOS desktop applications — something Selenium, Cypress, and Playwright can't do. Use image-based or native accessibility locators.
Automatic retry-until-success for element interactions. No more Thread.sleep() or explicit waits cluttering your tests.
Mix API calls and browser interactions in the same scenario. Set up test data via API, then verify the UI — all in one file.
The Karate Advantage
No other framework lets you combine API calls and browser automation in a single test file. Create data via API, then verify it renders correctly in the UI.
Set up test data with API calls — no database fixtures needed
Verify end-to-end workflows across the full stack
Clean up after tests with API teardown — no leftover state
Feature: End-to-End Order Flow
Scenario: Create order via API, verify in UI
# Step 1: Create order via API
Given url 'https://api.shop.com/orders'
And request { item: 'Laptop', qty: 1 }
When method post
Then status 201
* def orderId = response.id
# Step 2: Verify in browser
Given driver 'https://shop.com/orders'
And waitFor('{div}' + orderId)
Then match text('.status') == 'Pending'Comparison
Choose the right tool for your team.
| Feature | Karate | Selenium | Cypress |
|---|---|---|---|
| Resilient to UI change | Display-text + AI self-heal | Brittle selectors | Brittle selectors |
| No Java/JS knowledge needed | Yes | No (Java) | No (JS) |
| Built-in smart waits | Yes | Explicit waits only | Yes |
| API + UI in one test | Native | Not supported | Plugin needed |
| Cross-browser | All browsers | All browsers | Chrome, Firefox, Edge |
| Desktop app testing | Built-in | Not supported | Not supported |
| Visual regression | Built-in | Requires plugin | Plugin needed |
| Parallel execution | Built-in | Grid required | Dashboard (paid) |
| Performance testing | Same framework | Not supported | Not supported |
Start writing reliable browser tests in minutes with the open-source framework. Same syntax as your API tests — one framework for everything, free to start.