Enterprise vs. Open Source

REST, GraphQL and SOAP

One syntax across all three, no per-protocol DSL.

Plain-English Gherkin syntax

Tests read like the requirement they prove. No Java required.

Native JSON and XML

First-class payloads, not string manipulation.

Deep-equality match with fuzzy matchers

Replaces pages of assertion boilerplate.

Schema validation

Assert shape and type alongside values.

Data-driven scenarios

Table-driven outlines and dynamic data.

Parallel execution

Thread-safe by design, scales across cores.

CI/CD integration

Runs anywhere Java runs. No agent to install.

Java and JavaScript interop

Drop into code when the DSL is not enough.

Kafka

Produce, consume and assert alongside HTTP.

gRPC

Unary and streaming.

WebSocket

Bidirectional message assertions.

ActiveMQ and RabbitMQ

Queue and topic testing in the same suite.

Chrome, Edge, Firefox and WebKit

Cross-browser from one script.

Playwright-compatible driver

Use Playwright as a backend without rewriting.

Desktop application automation

Windows desktop apps alongside web.

Cross-OS execution

Windows, macOS, Linux.

Containerised browser testing

Run browsers in Docker for reproducibility.

HTTP mock server

Netty-backed and thread-safe.

Stateful mocks

Background runs once, so a CRUD double is a dozen lines.

Proxy mode

Forward most traffic, intercept selectively, rewrite responses.

Latency and failure injection

Non-blocking delays and on-demand error codes.

JavaScript mock handlers

Request, response and session objects. No Gherkin required.

CORS, SSL and hot reload

Browser-friendly mocks, edit while running.

Generate a mock from an OpenAPI spec

Import the document, export a working mock.

Stateful double as a provider stand-in

The precondition for any contract claim.

Run one suite against mock and provider

Same file, two targets. No broker, no pact file.

Classified divergence set

Six outcome classes including unassertedDivergence.

Four-rung evidence ladder

What the run entitles you to claim.

Waivers with a reason and an owner

Re-classify expected differences, flag stale rules.

Evidence that decays

Freshness computed at read time. Stale claims are withdrawn.

API coverage across protocols

OpenAPI, gRPC, GraphQL and Kafka in one matrix.

Requirement-to-test traceability

An RTM computed from real runs, not hand-maintained.

Mock-only disclosure

Flags a requirement whose only evidence came from a stand-in.

Multi-project aggregation

Roll coverage up across teams, domains and releases.

OpenAPI lint rulepack

Severity, message, JSON pointer and line on every finding.

Evidence rules

Claimed by a requirement, ever exercised, answered by more than a mock.

Five scored dimensions

Design, security, documentation, proven-ness, contract depth.

Ship verdict

READY, CONDITIONAL or NOT_READY, gated deterministically.

Six-level maturity ladder

Ungoverned through Proven. The top two need a run.

Spectral and vacuum ruleset import

Bring your ruleset, keep your findings.

Karate Agent

AI-native verification across API and UI.

Bring your own model

Claude, GPT, Gemini, Llama, Ollama and self-hosted.

Self-healing locators

Tests survive the next refactor.

MCP server

Agent-callable over Streamable HTTP.

Session recording

A complete audit trail of every agent action.

Air-gapped operation

Local model, zero outbound calls.

Deterministic verdicts, no model in the number

Grades are reproducible and attestable.

Functional tests as Gatling load tests

The same .feature file drives both.

karate-gatling

On Maven Central.

Syntax colouring

Karate and Gherkin, with embedded JavaScript

Run a feature from the editor

Gutter buttons, no terminal round-trip

Run a single scenario or example

Execute one row of an outline

Run configurations

Parameterise by environment and tag

Structure and outline view

Navigate large feature files

Code formatting

Align tables, normalise indentation

Test results inside the IDE

Native test runner panel

Auto-complete

Keyword completion after step prefixes

Code folding

Collapse scenarios and doc-strings

Jump to references

Navigate through read() and Java.type()

JSON re-formatting

Lenient, strict and single-line modes

Match syntax diagnostics

Real-time error highlighting on assertions

Run all tests in a folder

Context-menu execution

Step-through debugging

Breakpoints in feature files

Debug embedded JavaScript

Step through JS inside a feature

Debug Java and Karate in one session

One debugger stops in both

Run Karate Labs add-ons

Kafka and other add-ons from the IDE

Import OpenAPI or Swagger

Load a spec into a tool window.

Generate tests from a spec

Drag and drop an operation into a feature file.

Choose payload subsets

Select the JSON keys you want from a schema.

Impact analysis

Export schema metadata to diff spec changes over time.

SSO and SAML

Enterprise identity for the plugin licence.

Offline licensing

Air-gapped activation.

REST, GraphQL, SOAP and gRPC

JSON, XML and YAML payloads.

Response viewer

JSON tree, header inspector, schema hints.

Import a Postman collection

Runs every request, assertion and environment as-is.

Request chaining

Pipe a value from one response into the next request.

Environments and secret profiles

Shared variables, one-click switching.

Data-driven runs

Point at a CSV or JSON and parametrise.

Export to a .feature file

One click from exploration to a CI-ready test.

AI-assisted assertions

Paste a response, the model proposes expect() lines.

No sign-in required

Runs locally on macOS, Windows and Linux.

Try it from an OpenAPI spec

Execute any operation straight from the document.

Karate runner with live output

Run feature files inside Xplorer.

HTML reports

Shareable run reports from inside Xplorer.

MCP control

Drive Xplorer from a coding agent.

HTML test report

Standard run report, no server needed.

Coverage tab

What the run actually reached.

Traceability tab

Requirements joined to the tests that prove them.

Contract tab

The paired-run result and divergence set.

Governance tab

The graded spec, verdict and maturity level.

Runs 100% on your own infrastructure

No cloud, no test grid, no telemetry.

Single-tenant by design

Nothing shared, nothing multi-tenant.

Licence server and floating licences

Central provisioning and seat tracking.

SSO

Enterprise identity integration.

Role-based access control

Scope who can do what.

Audit logs

Who ran what, and when.

Community support

Forums, Stack Overflow and GitHub discussions.

Dedicated Slack with engineers, and an SLA

Commercial support.