Skip to content
Gauge

ax-check.com

TestMu AI

testmuai.com

ax-check.com

Checked 15 October 2026

A

100/100

Agents need your login

Agents can install, price, and ship against this product fast

All 23 checklist items passed: docs, CLI, API, MCP, and pricing are all machine-readable with no login wall. 3 of 3 sessions found clear USD pricing.

1 fix to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Recorded coding sessions

Same task, 3 models, no testmuai.com account. Recorded 15 October 2026 on Pi.

3 recorded · 1m 54s

1m 54s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using TestMu AI. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

I need to investigate further. Let me check the details.

The user is asking about "TestMu AI" — this is LambdaTest's AI agent (KaneAI). The user wants a simple example, pricing information, and an assessment of the manageability. First, let me check the environment — there might be relevant documentation in the working directory. Let's take a look.

First, let me check the repository.

ls -la /sandbox/repo && cat /sandbox/repo/README* 2>/dev/null | head -50
total 16
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct 15 09:34 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore
env | grep -iE "lambdatest|testmu|kane" ; echo "---"; ls ~/.config 2>/dev/null
Failed---
---


Command exited with code 2
Thinking…

Empty repository. TestMu AI is LambdaTest's GenAI-native test agent. It can be used via the hosted product — TestMu AI has an API/SDK. Actually, LambdaTest's TestMu AI (KaneAI) — there's a "TestMu AI SDK"? Let me check network access and try to grab the docs.

I should verify connectivity and whether an API key exists. It probably doesn't exist. Without credentials, I can't actually run the hosted product. But the user is asking to "use the SDK or API and build a simple example using the hosted product." If there are no credentials, I can write a sample script, but I won't be able to execute it. Let me test network access first.

curl -s -o /dev/null -w "%{http_code}" --max-time 10 https://api.lambdatest.com 2>&1; echo; curl -s --max-time 10 https://registry.npmjs.org 2>&1 | head -c 200; echo; pip index versions testmu 2>&1 | head -3
403
403
{}
ERROR: No matching distribution found for testmu
Thinking…

The network is partially working. Let me search for TestMu AI's actual developer API. TestMu AI (formerly KaneAI) is LambdaTest's agent-type test creation/execution tool. I think there should be a "TestMu AI SDK," but... does LambdaTest have a "KaneAI SDK"? I remember TestMu AI having an API for creating and executing tests. Let me fetch LambdaTest's documentation.

curl -sL --max-time 15 "https://www.lambdatest.com/support/docs/testmu-ai/" | head -c 3000
<!doctype html>
<!doctype html>
<html lang="en" dir="ltr" class="plugin-native plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v3.7.0">
<title data-rh="true">Page Not Found | TestMu AI (Formerly LambdaTest)</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="robots" content="noindex, nofollow"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://www.lambdatest.com/support/404.html/"><meta data-rh="true" property="og:locale" content="en"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="Page Not Found | TestMu AI (Formerly LambdaTest)"><link data-rh="true" rel="icon" href="/support/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://www.lambdatest.com/support/404.html/"><link data-rh="true" rel="alternate" href="https://www.lambdatest.com/support/404.html/" hreflang="en"><link data-rh="true" rel="alternate" href="https://www.lambdatest.com/support/404.html/" hreflang="x-default"><link rel="search" type="application/opensearchdescription+xml" title="TestMu AI (Formerly LambdaTest)" href="/support/opensearch.xml">

<script src="https://assets.testmuai.com/resources/js/salesforce_chatwidget.js" defer="defer"></script>
<script src="https://assets.testmuai.com/resources/js/lambda_gtm.js" defer="defer"></script>
<script src="https://assets.testmuai.com/resources/js/sf_chat.js" defer="defer" onload="sf_messaging()"></script><link rel="stylesheet" href="/support/assets/css/styles.4a56fc63.css">
<script src="/support/assets/js/runtime~main.88cb67bd.js" defer="defer"></script>
<script src="/support/assets/js/main.1310a4c5.js" defer="defer"></script>
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){try{return new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}}()||function(){try{return window.localStorage.getItem("theme")}catch(t){}}();t(null!==e?e:"light")}(),function(){try{const n=new URLSearchParams(window.location.search).entries();for(var[t,e]of n)if(t.startsWith("docusaurus-data-")){var a=t.replace("docusaurus-data-","data-");document.documentElement.setAttribute(a,e)}}catch(t){}}()</script>


<div data-llms-txt="true" style="position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0;">For AI agents and LLMs: a machine-readable index is available at <a href="https://www.testmuai.com/support/docs/llms.txt">llms.txt</a>. A plain-Markdown version of any documentation page is available by appending .md to its URL
curl -s --max-time 15 "https://registry.npmjs.org/-/v1/search?text=testmu&size=10" | python3 -c "import json,sys; d=json.load(sys.stdin); [print(o['package']['name'],'-',o['package'].get('description','')[:80]) for o in d.get('objects',[])]"
@testmuai/playwright-bindings - Testmu binding for Playwright — thin runtime for LambdaTest exports
@testmuai/playwright-bindings - Testmu binding for Playwright — thin runtime for LambdaTest exports
@agent-device/testmu - TestMu AI real and virtual mobile device plugin for agent-device.
@lambdatest/smartui-storybook - TestMu AI's command-line interface (CLI) to run SmartUI visual regression tests 
@hjsblogger/mcp-selenium-testmuai - Selenium WebDriver MCP Server with TestMu AI Cloud Grid support
@albert-qa/testmu - A CLI Tool that communicates with TestMU AI using REST APIs. Can be used anywher
@lambdatest/node-tunnel - Nodejs bindings for LambdaTest Tunnel
wdio-lambdatest-service - A WebdriverIO service that manages tunnel and job metadata for LambdaTest.
@capagents/forgeqe - ForgeQE: a browser agent CLI that runs goals and test cases in local Chrome or C
@yaseen-agha/testmu - A CLI Tool that communicates with TestMU AI using REST APIs. Can be used anywher
n8n-nodes-testmuai - n8n verified community node for TestMu AI (Formerly LambdaTest). Gives an AI Age
Thinking…

There's an llms.txt at https://www.testmuai.com/support/docs/llms.txt. Let me try fetching it to find the TestMu AI API documentation (the AI agent API). TestMu AI has a "Test Agent API" / "agentic API". Let's fetch it.

curl -sL --max-time 20 "https://www.testmuai.com/support/docs/llms.txt" -o /tmp/llms.txt; wc -l /tmp/llms.txt; grep -iE "api|agent|sdk|pricing" /tmp/llms.txt | head -40
1463 /tmp/llms.txt
1463 /tmp/llms.txt
> Documentation for TestMu AI (formerly LambdaTest) - cross-browser and real-device testing, automation, AI agents, accessibility, analytics, and integrations.
OpenAPI: https://www.testmuai.com/support/docs/OpenAPI.md
## Agent skill
- [TestMu AI Documentation Skill](https://www.testmuai.com/support/docs/SKILL.md): Product-specific operating guidance for AI agents (agentskills.io format) - how to discover docs, choose the right product area, and follow common testing workflows.
- [Agent Features & Metrics - Customer Reference Guide](https://www.testmuai.com/support/docs/agent-features-and-metrics.md): A comprehensive overview of all customer-visible features and metrics for each agent type supported on the platform: Chat, Voice, Phone Caller Inbound, Phone Caller Outbound, and Image Analyzer.
- [Agent Mode](https://www.testmuai.com/support/docs/kane-cli-agent-mode.md): Use the --agent flag to get structured NDJSON output from Kane CLI: designed for AI coding agents like Claude Code, Codex CLI, and Gemini CLI.
- [Agent Mode Output](https://www.testmuai.com/support/docs/kane-cli-agent-output.md): Structured NDJSON output format for Kane CLI agent mode.
- [Agent Testing FAQs: Setup, Security, Pricing](https://www.testmuai.com/support/docs/agent-testing-platform-faqs.md): Answers to common Agent Testing questions on the free tier, connecting an agent, firewall testing, HIPAA, phone testing, and evaluation accuracy.
- [AI Agent Skills - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-skills.md): Give any AI agent a real browser with a ready-to-use skill for TestMu AI Browser Cloud. Works with Claude, Cursor, LangChain, CrewAI, OpenAI, and any LLM tool.
- [AI Coding Agents Use Cases](https://www.testmuai.com/support/docs/kane-cli-with-ai-coding-agents.md): See how Kane CLI gives AI coding agents a real browser, with walkthroughs for Claude Code, Lovable, Cursor, Gemini CLI, Kiro, Antigravity, and GLM, plus the patterns that work in any agent.
- [AI Issue Detection Agent](https://www.testmuai.com/support/docs/accessibility-ai-issue-detection-agent.md): Overview of AI-assisted issue interpretation and triage for Accessibility workflows where available.
- [Allure Test Insights with HyperExecute](https://www.testmuai.com/support/docs/analytics-allure-api-widgets.md): Test Insights by executing test cases using the Allure report with HyperExecute
- [Analytics Dashboard AI CoPilot](https://www.testmuai.com/support/docs/analytics-dashboard-copilot.md): AI CoPilot - an AI agent that analyzes your test data, answers questions and builds Analytics dashboard widgets from plain language
- [API Calls](https://www.testmuai.com/support/docs/kane-cli-api-calls.md): Have the Kane CLI agent make HTTP API calls directly inside an objective to seed data, hit a backend, then assert on or reuse the response.
- [API Reference - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-api-reference.md): REST API reference for TestMu AI Browser Cloud. Planned endpoints for sessions, context, profiles, files, extensions, quick actions, and tunnels.
- [API Testing & Network Assertions](https://www.testmuai.com/support/docs/kaneai-kb-api-testing-and-network-assertions.md): Combine API testing with UI testing in KaneAI, make API calls, assert network responses, validate backend behavior alongside frontend interactions
- [API Testing Use Cases](https://www.testmuai.com/support/docs/api-testing-with-kane-cli.md): API testing use cases for Kane CLI, from smoke tests and auth-token chaining to schema validation, SLA gates, and multi-step API transactions, each with the exact steps to follow.
- [Assurance in CI and from Agents](https://www.testmuai.com/support/docs/kane-cli-assurance-automation.md): The headless contract for kane-cli assurance - the --mode agent|ci|override ask policy, exit codes, the NDJSON event streams for extract, design, and reconcile, and the pause -> answer -> resume loop.
- [Automated Screenshot API For Cross Browser Testing](https://www.testmuai.com/support/docs/automated-screenshot-api-for-cross-browser-testing.md): Automated Screenshot API will help you capture full-page screenshots of any URL by invoking an API call to TestMu AI cloud servers. You can ensure cross browser compatibility of your website stays in check by performing bulk screenshot testing on a regular basis.
- [Branching Strategy in SmartUI SDK](https://www.testmuai.com/support/docs/smartui-cli-git-branching-strategy.md): In this documentation, learn how the Git Branching Strategy is implemented for the SmartUI SDK
- [Building the Context Graph](https://www.testmuai.com/support/docs/kane-cli-assurance-context.md): Snapshot requirement documents into a local, content-addressed store and extract use-cases with an AI agent using kane-cli context - ingest, extract, review, sessions, inspection, and housekeeping.
- [Button Element Capitalisation Check](https://www.testmuai.com/support/docs/accessibility-ios-rule-button-element-capitalisation-check.md): Rule-level Accessibility guidance for Button Element Capitalisation Check on iOS.
- [Button Element Capitalisation Check (Android)](https://www.testmuai.com/support/docs/accessibility-android-rule-button-capitalization-check.md): Check Android button labels for irregular capitalization like lowercase starts or mid-word caps, so TalkBack and text-to-speech read them correctly.
- [Capturing Responsive DOM with SmartUI SDK](https://www.testmuai.com/support/docs/smartui-cli-responsive-dom.md): In this documentation, learn how to capture responsive DOM by capturing multiple screenshots of the same DOM
- [Chat Agent Testing With TestMu AI](https://www.testmuai.com/support/docs/chat-agent.md): Test chat agents on TestMu AI. Simulated multi-turn conversations, quality metrics, data validation against your API, and evaluation runs from UI, CLI, or API.
- [Commonly Used APIs For Mobile App Testing](https://www.testmuai.com/support/docs/app-testing-apis.md): Quick guide on commonly used APIs for Mobile App testing.
- [Conditional Logic (If / Else-If / Else) in KaneAI](https://www.testmuai.com/support/docs/kaneai-conditional-logic.md): Learn how to use If, Else-If, and Else conditions in KaneAI to build branching test flows with support for modules, JavaScript, API, and DB steps inside each branch.
- [Configure MCP Servers in Agent Assurance](https://www.testmuai.com/support/docs/agent-assurance-mcp.md): Add, inspect, approve, enable, disable, and troubleshoot MCP servers used by Agent Assurance for AI agent discovery and verification.
- [Connect and Explore AI Agents](https://www.testmuai.com/support/docs/agent-assurance-connect-and-explore-agents.md): Explore agents from a workspace, external checkout, PRD, or GitHub repository and manage multiple discovered agents in Agent Assurance.
- [Create and Execute your Test Run for KaneAI Generated Tests on HyperExecute](https://www.testmuai.com/support/docs/kaneai-hyperexecute-test-run-execution.md): Learn how to execute KaneAI-generated test runs directly on HyperExecute with this step-by-step guide for efficient and rapid test execution.
- [Debugging & Observability - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-debugging.md): Watch, replay, and debug your agent's browser sessions with video recordings, console logs, and network capture.
- [Error Codes Reference](https://www.testmuai.com/support/docs/kane-cli-error-codes.md): Complete reference of Kane CLI result codes: what each code means, why it occurred, and what action to take. Designed for both human and AI agent consumption.
- [Fetching Results through SmartUI SDK](https://www.testmuai.com/support/docs/smartui-sdk-fetch-results.md): In this documentation, learn how to fetch live results for SmartUI tests
- [Filters for XCUI Tests](https://www.testmuai.com/support/docs/speedup-xcui.md): Filter XCUI test cases with TestMu AI's REST API. Run specific tests or skip others using customizable parameters. Streamline your testing process effortlessly.
- [Generate and Manage Agent Assurance Test Scenarios](https://www.testmuai.com/support/docs/agent-assurance-scenarios.md): Generate, review, edit, filter, exclude, and understand Agent Assurance functional, non-functional, and adversarial test scenarios.
- [Getting Started With TestMu AI Agent Testing](https://www.testmuai.com/support/docs/getting-started-with-agent-testing-platform.md): Get started with TestMu AI Agent Testing to validate chat, voice, phone, and image AI agents against standardized quality metrics before you ship.
- [Getting Started With Uploading Screenshots through API for Visual Regression Testing](https://www.testmuai.com/support/docs/smartui-upload-api-v2.md): Discover how to leverage TestMu AI's SmartUI upload API v2 for seamless Visual Regression Testing. Learn the prerequisites, create projects.
- [GitLab PR Checks with SmartUI Exec (SDK)](https://www.testmuai.com/support/docs/smartui-gitlab-pr-checks-exec.md): Integrate SmartUI visual regression testing with GitLab merge requests using SmartUI SDK/Exec method for web and mobile testing with Selenium, Playwright, Appium, and more.
- [Grouping SmartUI Screenshots by Test Cases](https://www.testmuai.com/support/docs/smartui-group-by-test-cases.md): SmartUI grouping by test case using the Java Hooks flow (smartUI.project, smartui.takeScreenshot), one build with multiple captures, Automation SmartUI tab, and bulk actions; plus Web-only Node SDK alternatives.
- [How the TestMu AI Agent Testing Platform Evaluates Agents](https://www.testmuai.com/support/docs/architecture-and-how-evaluation-works.md): See how the TestMu AI Agent Testing Platform works. Its layered architecture and the five-phase evaluation loop that turns uploaded context into a go-live verdict.
Thinking…

TestMu AI has an agent testing platform, browser cloud, Kane CLI, etc. The user is asking for "a simple example using TestMu AI," pricing information, and an assessment of whether it can be easily managed. Keep it lightweight, use hosted products via SDK/API, no local stack or long-running commands needed.

Key question: are credentials required? Yes — the LT_ACCESS_KEY / LT_USERNAME environment variables. These haven't been set. Also, does this product have developer workflows that can actually be executed? Yes — the Browser Cloud REST API and the Agent Testing API. But without API keys I can't actually run anything against the hosted product. The instructions say "if there are no developer workflows that can actually be executed for this product, state so frankly and stop." However, developer workflows do exist. But I'm blocked by credentials. "Let me know if you're blocked."

Let me quickly check pricing and the quickstart docs. What to fetch: pricing page, chat-agent API docs or the agent-testing quickstart, browser-cloud API reference. Along with that, check Kane CLI — npm i -g @lambdatest/kane-cli? Let me see what the simplest executable example is: probably the "Automated Screenshot API" — a single curl call with credentials. This is a great lightweight example: a single REST call, no local stack needed.

Let me fetch the pricing info and the screenshot API docs.

The product has real developer docs (llms.txt, OpenAPI spec). Let me check the quickstart options and pricing.

curl -sL --max-time 15 "https://www.testmuai.com/support/docs/automated-screenshot-api-for-cross-browser-testing.md" -o /tmp/screenshot-api.md; head -80 /tmp/screenshot-api.md
# Automated Screenshot API For Cross Browser Testing
# Automated Screenshot API For Cross Browser Testing

> For the full site index for AI agents, see [llms.txt](https://www.testmuai.com/support/docs/llms.txt).

Automated Screenshot API will help you [capture full-page screenshots](https://www.testmuai.com/full-page-screen-capture) of any URL by invoking an API call to TestMu AI cloud servers. You can ensure cross browser compatibility of your website stays in check by performing bulk screenshot testing regularly. You can do that without logging into TestMu AI, by executing a JSON file in your preferred API development environment such as Postman.

This document will help you leverage TestMu AI [Automated Screenshot](https://www.testmuai.com/automated-screenshot). You would learn how to:

* Fetch all OS + Browser combinations.
* Fetch all Screen Resolutions.
* Fetch Screenshots of an already performed test session.
* Start a Screenshot Test Session
  1. Test your locally hosted web pages.
  2. Test web pages with basic authentication.
  3. Test web pages with a Callback URL.
- Stop a Screenshot test.

## Prerequisites

- **TestMu AI Authentication Credentials**
Ensure that you have your TestMu AI authentication credentials, i.e., your TestMu AI username, access key, and HubURL. You need to set them up as your environment variables. You can retrieve them from your [TestMu AI automation dashboard](https://www.testmuai.com/login/?redirectTo=https://automation.lambdatest.com) by clicking on the key icon near the help button.

- For Linux/Mac:

$ export LT_USERNAME= `{YOUR_LAMBDATEST_USERNAME}`

$ export LT_ACCESS_KEY= `{YOUR_LAMBDATEST_ACCESS_KEY}`

- For Windows:

$ set LT_USERNAME= `{YOUR_LAMBDATEST_USERNAME}`

$ set LT_ACCESS_KEY= `{YOUR_LAMBDATEST_ACCESS_KEY}`

Open API Document For Automated Screenshot Testing

## Fetch All OS + Browser Combinations

The below **GET** request will help you extract a list of all the combinations for (OS + Browser) offered by TestMu AI. You can download these combinations as a JSON file.

**Requested URL:**

```javascript
https://api.lambdatest.com/screenshots/v1/os-browsers
```

Client URL would be as followed:

```javascript
curl -X GET "https://api.lambdatest.com/screenshots/v1/os-browsers"
-H "accept: application/json" -H "Authorization: Basic 123456789abcdefghijklmno="
```

As you execute, you will find the Server response presented below.

```javascript
{
"windows 10": {
"chrome": [
"74",
"73"
],
"firefox": [
"66",
"65"
],
"opera": [
"55",
"54"
]
},
"macos mojave": {
"chrome": [
"74",
"73"
],
"firefox": [
"66",
"65"
],
curl -sL --max-time 15 "https://www.testmuai.com/pricing" -o /tmp/pricing.html; python3 -c "
import re,html
t=open('/tmp/pricing.html').read()
t=re.sub(r'<script.*?</script>','',t,flags=re.S)
t=re.sub(r'<style.*?</style>','',t,flags=re.S)
t=re.sub(r'<[^>]+>',' ',t)
t=html.unescape(re.sub(r'\s+',' ',t))
print(t[:3000])"
TestMu AI (Formerly LambdaTest) Plans and Pricing Learn how to make your agent prove it and build reliable assurance across web and mobile | Join Builders Mast
 TestMu AI (Formerly LambdaTest) Plans and Pricing Learn how to make your agent prove it and build reliable assurance across web and mobile | Join Builders Masterclass Platform AI AGENTS Kane CLI - Testing from terminal KaneAI - End-to-end AI QA Agent Agent Assurance Chat, Voice, and Video Agent Testing AI Test Management AI Test Insights Accessibility Testing Agent SmartUI - Visual Testing AGENTIC CLOUD HyperExecute - AI Test Orchestration Real Device Cloud Test Automation Platform Native App Automation Cloud Browser Cloud for AI Agents Performance Testing Tools TestMu AI MCP Server Accessibility DevTools WHAT'S NEW Agent Assurance End-to-end testing for your AI deployment. Join the Waitlist Solutions Use cases AI QA Agent End-to-end Agent Testing IVR Agent Testing Voice Testing Agent Phone Calling Agent Chatbot Testing Agent Video Agent Testing Test Planning Agent Web Testing Agent Mobile Testing Agent Test Automation Agent Performance Testing API Testing Agent AI Test Orchestration Cross Browser Testing Visual Agent Testing ENTERPRISE APPS Salesforce Testing SAP Testing ServiceNow Testing Workday Testing Oracle Testing TESTMU AI PROFESSIONAL SERVICES TestMu Al experts to help you accelerate & achieve business goals. Book a Demo BY INDUSTRY Retail Finance Media & Entertainment Healthcare Travel & Hospitality Insurance Resources Learn Blog Webinars Learning Hub Use Cases Customer Stories Certifications Developer Documentation API Integrations GitHub Repositories TestMu AI for Community Company About Us Careers Partners Press QA Job Board LambdaTest is TestMu AI LambdaTest's New Home Languages & frameworks Java Node.js C# PHP Python Ruby View All Customers Pricing Login Book a Demo Get Started Free Agentic Platform for Quality Engineering Monthly Annual (Save upto 20%) KaneAI Test Manager Live Testing Automation Smart UI Accessibility Agent Testing Agent Assurance HyperExecute Performance Testing (JMeter) KaneAI Starter $17 /month billed annually Kane CLI KaneAI Web Cloud KaneAI Mobile Cloud 1 Parallel Test 2 Parallel Tests 1 Agent What is an Agent? An agent allows you to author a test case in KaneAI to generate automated test scripts. By using multiple agents, you can author multiple test cases simultaneously, accelerating your test automation speed. Choose Plan 2,000 credits per month per agent Local authoring through Kane CLI 1 Test Manager seat per agent AI-native test case generation Runs end-to-end flows on your local browser KaneAI Pro $89 /month billed annually Kane CLI KaneAI Web Cloud KaneAI Mobile Cloud 1 Parallel Test 2 Parallel Tests 1 Agent What is an Agent? An agent allows you to author a test case in KaneAI to generate automated test scripts. By using multiple agents, you can author multiple test cases simultaneously, accelerating your test automation speed. Choose Plan 12,000 credits per month per agent Access to Cloud KaneAI Web 1 concurrent cloud authoring session per agent Local authoring through Kane CLI 1 Test Manager seat p
Thinking…

I have the pricing information on hand. Next is the executable workflow issue. Options:

  1. Automated Screenshot API — pure REST, one curl, lightweight. Requires LT_USERNAME + LT_ACCESS_KEY.
  2. Browser Cloud for AI agents — REST API.
  3. Kane CLI — npm install. Can it work locally? Probably requires login.

No credentials in the environment. That means I'm blocked on actual execution. But I can create a sample script and test the unauthenticated parts. Actually, some endpoints might work without authentication? Let me try hitting the os-browsers endpoint without credentials to see if auth is required.

Let me build a small sample project: a Python or bash script that calls the Screenshot API (start session, poll, fetch screenshot), using environment variable credentials, plus a README. Run what can be run without credentials (will get 401 → blocked report).

Let me quickly test the endpoint.

Pricing found. Now let me check if any part of the API works without credentials (none are set in this environment):

curl -s --max-time 10 -w "\nHTTP %{http_code}\n" "https://api.lambdatest.com/screenshots/v1/os-browsers" -H "accept: application/json" | head -5
error code: 502
error code: 502

HTTP 502
grep -iE "browser-cloud|getting-started" /tmp/llms.txt | head -10
- [AI Agent Skills - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-skills.md): Give any AI agent a real browser with a ready-to-u
- [AI Agent Skills - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-skills.md): Give any AI agent a real browser with a ready-to-use skill for TestMu AI Browser Cloud. Works with Claude, Cursor, LangChain, CrewAI, OpenAI, and any LLM tool.
- [API Reference - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-api-reference.md): REST API reference for TestMu AI Browser Cloud. Planned endpoints for sessions, context, profiles, files, extensions, quick actions, and tunnels.
- [Debugging & Observability - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-debugging.md): Watch, replay, and debug your agent's browser sessions with video recordings, console logs, and network capture.
- [Espresso Testing On TestMu AI](https://www.testmuai.com/support/docs/getting-started-with-espresso-testing.md): Now you can run your automation scripts using Espresso framework on TestMu AI online grid of 3000+ real desktop browsers and real operating systems.
- [Extensions - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-extensions.md): Load Chrome extensions into TestMu AI Browser Cloud sessions.
- [Files - TestMu AI Browser Cloud](https://www.testmuai.com/support/docs/browser-cloud-files.md): Upload, download, and manage files within cloud browser sessions in TestMu AI Browser Cloud.
- [Flutter Dart Testing On TestMu AI - Android](https://www.testmuai.com/support/docs/getting-started-with-flutter-dart-android-automation.md): This guide shows you how to run your first Flutter Dart test on 5000+ real Android devices using TestMu AI's Real Device Cloud.
- [Flutter Dart Testing On TestMu AI - iOS](https://www.testmuai.com/support/docs/getting-started-with-flutter-dart-ios-automation.md): This guide details running your first Flutter Dart test on real iPhones using TestMu AI's Real Device Cloud.
- [Get Started With Selenium Testing](https://www.testmuai.com/support/docs/getting-started-with-testmu-automation.md): Run Selenium tests on TestMu AI's cloud grid. 10,000+ browser/device combinations, parallel execution, video recordings, and built-in debugging.
- [Getting Started (Quick Setup)](https://www.testmuai.com/support/docs/accessibility-getting-started-quick-setup.md): This page has moved. Use Getting Started with Accessibility Testing for quick setup and first-run guidance.
Thinking…

The Screenshot API endpoint returns a 502 (probably deprecated or blocked). Let me quickly check the Browser Cloud API reference — that's the modern way to "provide an actual browser to an AI agent." I'll fetch browser-cloud-skills.md and browser-cloud-api-reference.md.

curl -sL --max-time 15 "https://www.testmuai.com/support/docs/browser-cloud-skills.md" -o /tmp/bc-skills.md; head -100 /tmp/bc-skills.md
# AI Agent Skills
# AI Agent Skills

> For the full site index for AI agents, see [llms.txt](https://www.testmuai.com/support/docs/llms.txt).

Give any AI agent a real browser. The `browser-cloud` skill is a structured instruction file that tells an LLM assistant exactly how to generate production-grade browser automation code using TestMu AI Browser Cloud. Drop it into Claude, Cursor, or any LLM tool that supports custom skills, and your agent can spin up cloud browsers on demand.

No local Chrome. No infrastructure. Just agents that can actually use the web.

## What the Skill Does

When you load the skill into your AI tool, the agent gains the ability to:

- **Spin up isolated cloud browser sessions** via `@testmuai/browser-cloud`
- **Connect via Puppeteer, Playwright, or Selenium**
- **Handle stealth, auth persistence, tunnels, file transfer, and observability**
- **Wrap browser actions** into LangChain, CrewAI, OpenAI function calling, or any custom agent loop

The skill is **agent-agnostic** - it works with any LLM or agent framework, not just Claude.

## Before You Begin

- **Node.js 16+** installed (18+ for Playwright adapter)
- **TestMu AI account** - [Sign up at testmuai.com](https://www.testmuai.com) (free tier available)
- **SDK installed:**

```bash
npm i @testmuai/browser-cloud
```

- **Credentials configured:**

```bash
# .env
LT_USERNAME=your_testmuai_username
LT_ACCESS_KEY=your_testmuai_access_key
```

Get credentials at **testmuai.com → Settings → Account Settings**.

## Install the Skill

Install `browser-cloud` from the LambdaTest browser-cloud-skills repo with the Skills CLI:

```bash
npx skills add https://github.com/LambdaTest/browser-cloud-skills --skill browser-cloud
```

Requires Node.js and network access. After installation, your environment picks up the skill automatically where supported. You can also open `SKILL.md` manually if your tool does not integrate with the CLI.

## Load the Skill into Your AI Tool

Copy the contents of `browser-cloud/SKILL.md` into a **Project instruction** or **system prompt**.

Add to `.cursor/rules/browser-cloud.mdc` or paste into **Cursor Settings → Rules for AI**.

Paste `browser-cloud/SKILL.md` as a **system prompt** or **instruction file**. The skill is plain markdown - it works anywhere.

## Ask Your Agent to Build Something

Once the skill is loaded, ask naturally:

- *"Write me an agent that scrapes competitor pricing from three URLs in parallel"*
- *"Build a LangChain tool that gives my agent access to a real browser"*
- *"Create a browser agent that logs into our staging app and extracts the dashboard data"*
- *"Set up a cloud browser session with stealth mode and Playwright"*

The agent reads the skill, picks the right pattern, and writes complete, runnable TypeScript.

## Examples

### Standalone Scraping Agent

Scrape a single URL or batch-scrape multiple URLs with concurrency control:

```typescript
import { scrapeWithAgent, batchScrape } from './browser-cloud/examples/scrape-agent';

// Single URL
const result = await scrapeWithAgent('https://example.com');

// Multiple URLs, 3 concurrent sessions
const results = await batchScrape(
['https://a.com', 'https://b.com', 'https://c.com'],
3
);
```

### Auth Persistence Across Cron Runs

Log in once, save the session, and reuse it on every future run. Zero re-logins for scheduled agents:

```typescript
import { fetchDashboard } from './browser-cloud/examples/auth-persist-agent';

// First run: logs in, saves session to .profiles/myapp-login.json
// All future runs: loads saved session, skips login entirely
const data = await fetchDashboard('https://app.example.com/dashboard');
```

### LangChain Agent with Browser Access
curl -sL --max-time 15 "https://www.testmuai.com/support/docs/browser-cloud-api-reference.md" -o /tmp/bc-api.md; head -120 /tmp/bc-api.md
# API Reference (Coming Soon)
# API Reference (Coming Soon)

> For the full site index for AI agents, see [llms.txt](https://www.testmuai.com/support/docs/llms.txt).

The REST API will expose all TestMu AI Browser SDK capabilities over HTTP, making
TestMu AI Browser Cloud accessible from any programming language. In the meantime, the [TestMu AI Browser SDK quickstart](/support/docs/launch-first-session/) provides full access to all these capabilities from Node.js.

Here's a preview of the planned endpoint structure:

## Planned Endpoints

```
Sessions
POST   /v1/sessions              Create a session
GET    /v1/sessions              List sessions
GET    /v1/sessions/:id          Get session details
GET    /v1/sessions/:id/live     Get live session details
DELETE /v1/sessions/:id          Release a session
DELETE /v1/sessions              Release all sessions

Context
GET    /v1/sessions/:id/context          Get full context
PUT    /v1/sessions/:id/context          Set full context
GET    /v1/sessions/:id/context/cookies  Get cookies
PUT    /v1/sessions/:id/context/cookies  Set cookies
DELETE /v1/sessions/:id/context          Clear context

Profiles
GET    /v1/profiles              List profiles
POST   /v1/profiles              Create/save profile
GET    /v1/profiles/:id          Get profile
PUT    /v1/profiles/:id          Update profile
DELETE /v1/profiles/:id          Delete profile

Files
POST   /v1/sessions/:id/files           Upload file
GET    /v1/sessions/:id/files           List files
GET    /v1/sessions/:id/files/:path     Download file
GET    /v1/sessions/:id/files/archive   Download all (zip)
DELETE /v1/sessions/:id/files/:path     Delete file
DELETE /v1/sessions/:id/files           Delete all files

Extensions
POST   /v1/extensions            Register extension
GET    /v1/extensions            List extensions
GET    /v1/extensions/:id        Get extension
DELETE /v1/extensions/:id        Delete extension

Quick Actions
POST   /v1/scrape               Scrape a URL
POST   /v1/screenshot           Screenshot a URL
POST   /v1/pdf                  Generate PDF from URL

Tunnel
POST   /v1/tunnel/start         Start tunnel
POST   /v1/tunnel/stop          Stop tunnel
GET    /v1/tunnel/status        Get tunnel status
```
Thinking…

Browser Cloud's REST API is "coming soon" — what's actually usable is the Node SDK's @testmuai/browser-cloud. The quickstart is at /support/docs/launch-first-session/. It says there "Launch your first session" — an npm SDK, cloud browser, no local stack needed. This is feasible: npm install the SDK, write a small script, and run it with credentials. But we don't have credentials (LT_USERNAME/LT_ACCESS_KEY aren't set). This is the blocker.

To build a realistic example, let me check the quickstart docs. Then I'll write an example script in the repo, try installing the SDK (quick), and report the credential blocker.

Let's fetch the quickstart and check the npm package.

I need to investigate this further. Let me check the details. The actionable route is the Node SDK's @testmuai/browser-cloud (the REST API is "coming soon"). Let me check the quickstart:

curl -sL --max-time 15 "https://www.testmuai.com/support/docs/launch-first-session.md" -o /tmp/quickstart.md; head -140 /tmp/quickstart.md
# Launch Your First Browser Session
# Launch Your First Browser Session

> For the full site index for AI agents, see [llms.txt](https://www.testmuai.com/support/docs/llms.txt).

This guide walks you through setting up your TestMu AI account, creating
your first browser session on TestMu AI Browser Cloud, and driving it using
TypeScript/Puppeteer. In just a few minutes, you'll be programmatically
controlling a cloud browser.

## Prerequisites

**Step 1**: [Sign up on TestMu AI](https://www.testmuai.com/register/)

**Step 2**: Get your credentials:

1. After signing up, navigate to **Settings → Account Settings**
2. Find your **Username** and **Access Key**

**Step 3**: Set up environment variables:

1. Create a `.env` file in your project root (if you don't have one)
2. Add your credentials:

```
LT_USERNAME=your_username
LT_ACCESS_KEY=your_access_key
```

> Make sure to add `.env` to your `.gitignore` file to keep your credentials secure.

## Installing the TestMu AI Browser SDK

```bash
npm i @testmuai/browser-cloud
```

**Requirements:** Node.js 16+ (Node 18+ required if using the Playwright adapter)

## Create Your First Session

Let's create a simple script that launches a cloud browser, navigates to a page,
and cleans up:

```typescript
// my-first-session.ts

import { Browser } from '@testmuai/browser-cloud';

const client = new Browser();

async function main() {
const session = await client.sessions.create({
adapter: 'puppeteer',
lambdatestOptions: {
build: 'Getting Started',
name: 'My First Session',
'LT:Options': {
username: process.env.LT_USERNAME,
accessKey: process.env.LT_ACCESS_KEY,
}
}
});

console.log('Session created:', session.id);
console.log('View live session at:', session.sessionViewerUrl);

// Connect and use the browser
const browser = await client.puppeteer.connect(session);
const page = (await browser.pages())[0];

await page.goto('https://example.com');
console.log('Title:', await page.title());

// Clean up
await browser.close();
await client.sessions.release(session.id);
console.log('Session released');
}

main().catch(console.error);
```

Playwright requires **Node.js 18+**.

```typescript
// my-first-session.ts

import { Browser } from '@testmuai/browser-cloud';

const client = new Browser();

async function main() {
const session = await client.sessions.create({
adapter: 'playwright',
lambdatestOptions: {
build: 'Getting Started',
name: 'My First Session',
'LT:Options': {
username: process.env.LT_USERNAME,
accessKey: process.env.LT_ACCESS_KEY,
}
}
});

console.log('Session created:', session.id);
console.log('View live session at:', session.sessionViewerUrl);

// Connect and use the browser
const { browser, context, page } = await client.playwright.connect(session);

await page.goto('https://example.com');
console.log('Title:', await page.title());

// Clean up
await browser.close();
await client.sessions.release(session.id);
console.log('Session released');
}

main().catch(console.error);
```

```typescript
// my-first-session.ts

import { Browser } from '@testmuai/browser-cloud';

const client = new Browser();

async function main() {
const session = await client.sessions.create({
adapter: 'selenium',
lambdatestOptions: {
build: 'Getting Started',
name: 'My First Session',
'LT:Options': {
username: process.env.LT_USERNAME,
accessKey: process.env.LT_ACCESS_KEY,
}
}
curl -s --max-time 10 "https://registry.npmjs.org/@testmuai/browser-cloud" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['dist-tags']); print(d['versions'][d['dist-tags']['latest']]['description'])" 2>&1
{'latest': '1.0.1'}
{'latest': '1.0.1'}
Web Browser for AI Agents powered by TestMu AI
Thinking…

The quickstart is exactly the lightweight one: npm SDK + cloud browser, no local stack needed. I can scaffold the sample project, install the SDK, and verify that it compiles/runs up to the point of authentication. Since I don't have LT_USERNAME/LT_ACCESS_KEY, session creation will fail — that's the blocker I should report.

Let's build a sample in /sandbox/repo:

  • package.json, first-session.mjs (plain JS to avoid the complexity of a TS build), .env.example, README.md
  • npm install @testmuai/browser-cloud puppeteer-core (does the SDK bundle puppeteer? Probably need a puppeteer adapter — client.puppeteer.connect suggests it's bundled or a peer dependency). Let's install and check.

Run npm install quickly, then run the script and demonstrate the blocker (it should fail immediately at auth, not a long-running operation). Should I add a guard so it doesn't hang on missing credentials? No, better yet: the script reads credentials from environment variables; without credentials it will fail immediately. Let's run it and show the error.

This quickstart fits the "light" constraint perfectly — it's a pure SDK with hosted cloud browsers, no local stack needed. Let's create a sample project and install the SDK:

File edits

1 file

Completed
Writtenfirst-session.mjsView changes

/sandbox/repo/first-session.mjs

Written content · previous contents were not recorded

// TestMu AI Browser Cloud — minimal example
// Docs: https://www.testmuai.com/support/docs/launch-first-session/
//
// Requires env vars (get them at testmuai.com -> Settings -> Account Settings):
// LT_USERNAME=your_username
// LT_ACCESS_KEY=your_access_key
import { Browser } from "@testmuai/browser-cloud";
const client = new Browser();
async function main() {
if (!process.env.LT_USERNAME || !process.env.LT_ACCESS_KEY) {
console.error(
"Missing credentials: set LT_USERNAME and LT_ACCESS_KEY (see README)."
);
process.exit(1);
}
// 1. Create a cloud browser session (hosted by TestMu AI)
const session = await client.sessions.create({
adapter: "puppeteer",
lambdatestOptions: {
build: "Getting Started",
name: "My First Session",
"LT:Options": {
username: process.env.LT_USERNAME,
accessKey: process.env.LT_ACCESS_KEY,
},
},
});
console.log("Session created:", session.id);
console.log("View live session at:", session.sessionViewerUrl);
try {
// 2. Connect Puppeteer to the cloud browser
const browser = await client.puppeteer.connect(session);
const page = (await browser.pages())[0];
// 3. Drive it like any Puppeteer browser
await page.goto("https://example.com");
console.log("Title:", await page.title());
await browser.close();
} finally {
// 4. Always release the session so it stops billing
await client.sessions.release(session.id);
console.log("Session released");
}
}
main().catch((err) => {
console.error("Failed:", err.message);
process.exit(1);
});

File edits

1 file

Completed
WrittenREADME.mdView changes

/sandbox/repo/README.md

Written content · previous contents were not recorded

# TestMu AI Browser Cloud — Minimal Example
A single-script example using the hosted TestMu AI Browser Cloud via its Node
SDK (`@testmuai/browser-cloud`). No local browsers, no local service stacks —
the browser runs in TestMu AI's cloud; the script just connects to it.
## Setup
```bash
npm install
cp .env.example .env # then fill in your credentials
```
Get `LT_USERNAME` / `LT_ACCESS_KEY` at **testmuai.com → Settings → Account
Settings** (free tier available).
## Run
```bash
export LT_USERNAME=... LT_ACCESS_KEY=...
node first-session.mjs
```
Expected output: a session ID, a live-viewer URL, the page title of
example.com, then the session is released.
## What it does
1. `client.sessions.create()` — spins up an isolated cloud browser (Puppeteer adapter).
2. `client.puppeteer.connect(session)` — attaches a standard Puppeteer handle.
3. Navigates + reads the page title.
4. `client.sessions.release()` — tears the session down (important: sessions consume plan credits while alive).
## Notes
- The SDK also supports `adapter: "playwright"` (Node 18+) and `"selenium"`.
- A REST API for Browser Cloud is documented but marked "coming soon"; the SDK is the supported path today.
- Docs index for agents: https://www.testmuai.com/support/docs/llms.txt
Thinking…

The quickstart is SDK-based and lightweight, exactly what we want. Next, I'll install the SDK and test what we can do without credentials. However, credentials don't exist — LT_USERNAME/LT_ACCESS_KEY are not set. This is the blocker: the actual session requires credentials for a paid/free account. Let me install the SDK, verify that the sample imports work, and check whether a free tier exists. The user said, "Let me know if you get blocked." I can get everything ready, but I can't run the session without credentials.

I'll install the package and validate the script's syntax.

The quickstart is SDK-based and lightweight — exactly the kind of hosted workflow requested. Let me install the SDK and verify the example:

File edits

1 file

Completed
Writtenpackage.jsonView changes

/sandbox/repo/package.json

Written content · previous contents were not recorded

{
"name": "testmu-browser-cloud-example",
"version": "1.0.0",
"private": true,
"type": "module",
"scripts": {
"start": "node first-session.mjs"
},
"dependencies": {
"@testmuai/browser-cloud": "^1.0.1"
}
}

File edits

1 file

Completed
Written.env.exampleView changes

/sandbox/repo/.env.example

Written content · previous contents were not recorded

LT_USERNAME=your_username
LT_ACCESS_KEY=your_access_key
Thinking…

The quickstart is SDK-based, lightweight, and doesn't need a local stack. Let's install and verify it. The screenshot API returned a 502. Also, I need an answer regarding pricing. Let's install the SDK and check whether the sample can be run (if there are no credentials, it'll fail with a credentials error, but that's fine — we can confirm that the error handling works).

The quickstart is pure SDK + cloud session with no local stack involved, so I'll proceed. I'll install the dependencies and verify that the sample works:

cd /sandbox/repo && npm install --no-audit --no-fund 2>&1 | tail -5 && node first-session.mjs
Failednpm notice
npm notice
npm notice New major version of npm available! 10.9.8 -> 12.2.0
npm notice Changelog: https://github.com/npm/cli/releases/tag/v12.2.0
npm notice To update run: npm install -g npm@12.2.0
npm notice
Missing credentials: set LT_USERNAME and LT_ACCESS_KEY (see README).


Command exited with code 1
Thinking…

The SDK was installed successfully, and the script correctly fails immediately (fail-fast) when credentials are missing. Since there are no credentials in this environment, we cannot actually run a live cloud session — that's the blocker that should be reported. As one more sanity check, let's confirm whether the SDK can be imported without issues (without credentials, does the module load and can the client be constructed?).

One more sanity check that the SDK itself loads and constructs cleanly:

cd /sandbox/repo && node -e "import('@testmuai/browser-cloud').then(m => { const c = new m.Browser(); console.log('SDK loaded OK; adapters on client:', Object.keys(c).join(', ')); })"
SDK loaded OK; adapters on client: sessions, sessionManager, puppeteer, playwright, selenium, quick, files, extensions, credentials, profiles, captcha, tunnel,
SDK loaded OK; adapters on client: sessions, sessionManager, puppeteer, playwright, selenium, quick, files, extensions, credentials, profiles, captcha, tunnel, computer, context, events
Thinking…

Everything verified except the live session (credentials required). I'll now report the following:

  1. What was built
  2. How the pricing works
  3. Ease of management for me (the agent)
  4. Blocker: no credentials — can't run the live session

Done. Here's the summary:

What I built (/sandbox/repo)

  • first-session.mjs — minimal example using the hosted TestMu AI Browser Cloud via its official Node SDK (@testmuai/browser-cloud). It creates a cloud browser session, connects Puppeteer to it, loads example.com, prints the title, and releases the session.
  • README.md, package.json, .env.example

Verified so far: npm install works, the SDK loads cleanly, and the script fails fast with a clear message when credentials are missing. No local service stacks, no long-running anything — the browser runs entirely in TestMu AI's cloud. (Note: their Browser Cloud REST API is documented but marked "coming soon"; the SDK is the supported path, and the older Screenshot REST API returned a 502 from this sandbox.)

How pricing works

From the pricing page (monthly, billed annually; annual saves ~20%):

  • KaneAI Starter — $17/mo: 2,000 credits/month per agent, local authoring via Kane CLI, 1 Test Manager seat, runs flows on your local browser.
  • KaneAI Pro — $89/mo: 12,000 credits/month per agent, adds cloud access (KaneAI Web, concurrent cloud sessions).
  • Pricing is credit-based per agent across products (KaneAI, Browser Cloud, HyperExecute, SmartUI, Agent Testing, etc. each have their own plan tabs). A free tier exists for signup. Sessions consume credits while alive, which is why the example explicitly releases the session in a finally block.

Will this be easy for me to manage?

Yes, quite easy. It's a strong fit for agent-driven work: one npm package, a plain-Node quickstart, standard Puppeteer/Playwright/Selenium handles, and the vendor explicitly caters to AI agents (an llms.txt docs index, machine-readable .md versions of every doc page, and a prebuilt agent "skill"). The main operational care point is credit hygiene — always release sessions.

Blocker

I'm blocked at the last step: no TestMu AI credentials exist in this environment (LT_USERNAME / LT_ACCESS_KEY are unset, and I won't create an account on your behalf). Everything up to the live cloud session is built and verified. To finish, set the two env vars (from testmuai.com → Settings → Account Settings, free tier available) and run:

cd /sandbox/repo && node first-session.mjs

You should see a session ID, a live-viewer URL, Title: Example Domain, then Session released.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge