Frequently Asked Questions

Keploy is an open-source, AI-powered testing agent and sandboxing platform that automatically generates test cases, dependency mocks, and production-like sandboxes from real user traffic. It uses eBPF kernel technology for system-level visibility, helping teams achieve 90% test coverage in minutes with zero code changes.

Unlike traditional testing tools that require manual test writing, Keploy automatically captures real production traffic and generates test cases using eBPF at the Linux kernel level. It eliminates the need for maintaining mocks manually, provides dependency virtualization, AI-powered noise detection for flaky test elimination, and production-like sandboxes. No code changes are required.

Keploy supports Go (Gin, Echo, Fiber, Chi), Java (Spring Boot, Quarkus, Micronaut), TypeScript/JavaScript (Express, Fastify, NestJS), Python (Django, Flask, FastAPI), and Node.js. Because Keploy operates at the network/kernel layer using eBPF, it is fundamentally language-agnostic and can test any application that makes network calls.

eBPF (extended Berkeley Packet Filter) is a Linux kernel technology that allows programs to run safely within the kernel. Keploy uses eBPF to intercept network packets at the socket level with near-zero overhead, capturing all API traffic and dependency calls without code changes, language-specific SDKs, or application restarts.

Yes. Keploy's core platform is open-source and available on GitHub with 17,000+ GitHub stars. Advanced analytics, SSO, team dashboards, and enterprise features are available through the managed cloud platform at app.keploy.io.

API testing validates that application programming interfaces work correctly, return expected responses, and handle errors properly. It is critical for microservices architectures where services communicate via APIs, ensuring reliability before production deployment.

Keploy captures real API traffic using eBPF kernel hooks, recording HTTP requests, responses, and all dependency interactions. These recordings are automatically converted into replayable test cases with mocked dependencies, eliminating manual test writing entirely.

No. Keploy operates at the network layer using eBPF technology, capturing traffic at the Linux kernel level without instrumenting application code. This makes it ideal for testing legacy APIs and systems not designed for testability.

Keploy uses AI-powered noise detection to identify and filter non-deterministic fields like timestamps, UUIDs, and session tokens. This eliminates flaky test failures without manual assertion configuration.

Yes. Keploy provides native integration with GitHub Actions, GitLab CI, Jenkins, CircleCI, and Bitbucket Pipelines. Generated API tests run automatically on every commit, providing continuous regression detection with zero test maintenance.

Keploy's UTG is an AI-powered tool that automates the creation of unit tests based on code semantics. It analyzes your source code, generates comprehensive test suites with meaningful assertions and edge case coverage, and produces detailed Cobertura format coverage reports.

Keploy does not send any user code to remote systems, except when using the unit test generation feature. When using UT gen, only source code and test code are sent to the LLM you configure. If your organization has a private LLM, you can use it with Keploy to ensure data stays internal.

Yes. Keploy is designed to handle large codebases efficiently. The UT generator processes code incrementally and supports intelligent caching. Processing time may vary based on project size and complexity, but most teams see under 15% additional CI runtime.

Keploy generates detailed Cobertura format reports that integrate with standard CI/CD dashboards and code quality tools. These reports provide line-level coverage data, branch coverage, and insights into untested code paths.

Keploy's Unit Test Generator is available as a VS Code extension with over 1 million installs and as a JetBrains plugin for IntelliJ IDEA, PyCharm, WebStorm, and GoLand. You can generate tests directly within your IDE workflow.

Mocks are automatically generated from recorded network interactions using dependency virtualization. In Test mode, Keploy replays recorded dependency responses including database results, API responses, and message queue payloads, eliminating the need for manual mock creation or external test environments.

Contract testing verifies that microservices communicate as expected by validating their request and response structures. Keploy captures API interactions and automatically generates contract tests that validate API contracts during subsequent runs, ensuring communication integrity between services.

Yes. Keploy captures production baselines before migration, then validates that application behavior remains identical after changes. This migration regression testing catches regressions in service-to-service communication, database interactions, and API contracts during Kubernetes migrations or framework updates.

Keploy creates production-like sandboxes by replaying captured production traffic with all dependencies automatically virtualized. This provides production-fidelity validation without maintaining expensive, hard-to-configure staging environments, reducing infrastructure costs by up to 90%.

Yes. Keploy is specifically designed to test legacy monoliths, dependency-heavy systems, and brownfield applications without requiring code changes. Because eBPF operates at the kernel network layer, it captures traffic from any application regardless of language, framework, or architecture.

Install Keploy with a one-line command, run your application in Record mode to capture real traffic interactions, then switch to Test mode to replay generated tests with automatic dependency mocking. Visit docs.keploy.io for language-specific quickstart guides for Go, Java, Python, and Node.js.

Yes. Keploy integrates seamlessly with your existing testing infrastructure. You can run Keploy-generated tests alongside your current test suite using standard test runners like JUnit, pytest, Jest, and Go test. Gradual adoption is fully supported.

Yes. Keploy is built for cloud-native Kubernetes environments with support for containerized deployments, microservices architectures, and service mesh configurations. Helm charts and an operator are available for cluster-level deployment.

Keploy processes data locally by default. Recorded test data stays in your infrastructure. Sensitive fields are auto-redacted and you can add custom masking rules. For cloud features, all data is encrypted in transit and at rest using AES-256 encryption.

Yes. Keploy can be deployed entirely on-premise or in your private cloud, ensuring complete data sovereignty and control. Enterprise plans include full support for on-premise deployments with custom SLAs.

Keploy offers four tiers: Free (core testing features for individual developers), Professional (advanced features with priority support), Business (team collaboration and dedicated support), and Enterprise (custom solutions with SLA guarantees and on-premise deployment). The open-source core is free.

The free plan includes unlimited test recording, up to 1,000 test replays per month, basic CI/CD integrations, community support through Slack and GitHub discussions, and access to all core Keploy features for individual developers and small projects.

The Lines of Code limit refers to the amount of code that can be analyzed for unit test generation. Professional tier users get 1,000 LoC per user with options to add more. The Open Source version allows up to 5,000 LoC in total.

Yes. Keploy offers special pricing for educational institutions and non-profit organizations. Contact the sales team with your organization details to discuss available discounts and custom plans.