@@ -116,4 +119,4 @@ After uploading your application, please wait atleast for 1-2 minutes for the ap
**Step 4:** Once your session starts and biometric authentication is enabled for the app, use Lambdatest's **Biometric Authentication** pop-up shown below to interact with any instance where biometric authentication is invoked.
-
.default})
\ No newline at end of file
+
.default})
diff --git a/docs/biometric-authentication.md b/docs/biometric-authentication.md
index 8d993c824..ef5973315 100644
--- a/docs/biometric-authentication.md
+++ b/docs/biometric-authentication.md
@@ -2,7 +2,7 @@
id: biometric-authentication
title: Biometric Authentication
sidebar_label: Biometric Authentication
-description: Test biometric authentication functionalities such as fingerprint or face recognition in your app on LambdaTest Real Device Cloud Platform with 10000+ real mobile devices.
+description: Test biometric authentication functionalities such as fingerprint or face recognition in your app on TestMu AI Real Device Cloud Platform with 3000+ real mobile devices.
keywords:
- biometric authentication
- Fingerprint authentication
@@ -10,15 +10,16 @@ keywords:
- Biometric security
- Biometric Authentication Testing
- Barcode scanning
- - lambdatest capture code
- - framework on lambdatest
+ - testmu ai capture code
+ - framework on testmu ai
- Facial recognition
- app testing appium
- app testing
- real devices
-url: https://www.lambdatest.comsupport/docs/biometric-authentication/
-site_name: LambdaTest
+url: https://www.testmuai.com/support/docs/biometric-authentication/
+site_name: TestMu AI
slug: biometric-authentication/
+canonical: https://www.testmuai.com/support/docs/biometric-authentication/
---
import CodeBlock from '@theme/CodeBlock';
@@ -27,6 +28,8 @@ import {YOUR_LAMBDATEST_USERNAME, YOUR_LAMBDATEST_ACCESS_KEY} from "@site/src/co
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
import RealDeviceTag from '../src/component/realDevice';
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
Biometric Authentication is a security process that leverages the unique biological characteristics of individuals to verify their identities. In native applications, it is often used to provide a seamless, secure, and efficient user experience.
-LambdaTest now supports Biometric Authentication for real devices (iOS and android). This new feature allows you to test your application's biometric authentication functionality more accurately and ensures your app provides an optimal user experience across a range of devices and platforms.
+
now supports Biometric Authentication for real devices (iOS and android). This new feature allows you to test your application's biometric authentication functionality more accurately and ensures your app provides an optimal user experience across a range of devices and platforms.
:::info
**OS Version:** Biometric authentication is supported only on Android devices with OS version `11` or `above`, and on iOS devices with OS version `13` or `above`.
@@ -110,10 +113,6 @@ To enable biometric authentication feature in your automation script, set the ca
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setcapability("enableBiometricsAuthentication",true)
```
-:::note
-Explicitly set the `autoAcceptAlerts` capability to false in order to run biometric tests on iOS devices.
-:::
-
### Using Lambda-Hook
@@ -131,6 +130,7 @@ driver.execute_script("lambda-biometric-injection=fail")
:::note
- To use the web hook, passing `enableBiometricsAuthentication` capability is mandatory.
- If you plan to use the **Uninstall Lambda Hook**, and then the **Install Lambda Hook** for the same application, biometric authentication can be used afterwards only via the lambda-hook. In this case, the initial capability won't be applicable anymore.
+- When biometric capability is `true`, set `autoAcceptAlerts` and `autoDismissAlerts` to `false`. For help, contact [support](https://www.testmuai.com/support/docs/).
:::
-> 📕 Check the [documentation for Biometrics Authentication](/support/docs/biometric-authentication-on-real-devices/) feature in Manual App Testing on Real devices
\ No newline at end of file
+> 📕 Check the [documentation for Biometrics Authentication](/support/docs/biometric-authentication-on-real-devices/) feature in Manual App Testing on Real devices
diff --git a/docs/bitbucket-pipeline-with-hyperexecute.md b/docs/bitbucket-pipeline-with-hyperexecute.md
index 89a334fa4..b102c238f 100644
--- a/docs/bitbucket-pipeline-with-hyperexecute.md
+++ b/docs/bitbucket-pipeline-with-hyperexecute.md
@@ -3,18 +3,21 @@ id: bitbucket-pipeline-with-hyperexecute
title: Bitbucket Pipeline Integration
hide_title: true
sidebar_label: Bitbucket
-description: HyperExecute now integrates with Bitbucket CI to boost your go-to market delivery. Perform automated cross browser testing with LambdaTest to ensure your development code renders seamlessly through an online Selenium grid providing 3000+ real browsers running through machines.
+description: HyperExecute now integrates with Bitbucket CI to boost your go-to market delivery. Perform automated cross browser testing with TestMu AI to ensure your development code renders seamlessly through an online Selenium grid providing 3000+ real browsers running through machines.
keywords:
- - lambdatest integrations
- - lambdatest integrations with ci/cd tools
+ - testmu ai integrations
+ - testmu ai integrations with ci/cd tools
- ci/cd tools
- continuous integration,continuous delivery
- continuous integration tools
- gitlab ci
-url: https://www.lambdatest.com/support/docs/bitbucket-pipeline-with-hyperexecute/
-site_name: LambdaTest
+url: https://www.testmuai.com/support/docs/bitbucket-pipeline-with-hyperexecute/
+site_name: TestMu AI
slug: bitbucket-pipeline-with-hyperexecute/
+canonical: https://www.testmuai.com/support/docs/bitbucket-pipeline-with-hyperexecute/
---
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
GitHub repository to run the tests on the HyperExecute.
View on GitHub
:::
@@ -148,12 +151,12 @@ pipelines:
\ No newline at end of file
+
diff --git a/docs/bitbucket-pipelines-integration.md b/docs/bitbucket-pipelines-integration.md
index ddb6f3697..5beb3f7e2 100644
--- a/docs/bitbucket-pipelines-integration.md
+++ b/docs/bitbucket-pipelines-integration.md
@@ -1,19 +1,22 @@
---
id: bitbucket-pipelines-integration
-title: Bitbucket Pipelines Integration With LambdaTest
+title: Bitbucket Pipelines Integration With TestMu AI
hide_title: true
sidebar_label: Bitbucket Pipelines
-description: LambdaTest integration with Bitbucket Pipelines will help you perform cross-browser testing on 3000+ real browsers & browser versions, through a Selenium Grid hosted on LambdaTest cloud servers.
+description: TestMu AI integration with Bitbucket Pipelines will help you perform cross-browser testing on 3000+ real browsers & browser versions, through a Selenium Grid hosted on TestMu AI cloud servers.
keywords:
- bitbucket pipelines
- - bitbucket integration with lambdatest
+ - bitbucket integration with testmu ai
- continuous delivery pipeline
- bitbucket pipelines for continuous delivery
-url: https://www.lambdatest.com/support/docs/bitbucket-pipelines-integration-with-lambdatest/
-site_name: LambdaTest
-slug: bitbucket-pipelines-integration-with-lambdatest/
+url: https://www.testmuai.com/support/docs/bitbucket-pipelines-integration-with-testmu/
+site_name: TestMu AI
+slug: bitbucket-pipelines-integration-with-testmu/
+canonical: https://www.testmuai.com/support/docs/bitbucket-pipelines-integration-with-testmu/
---
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
-# Bitbucket Pipelines Integration With LambdaTest
+# Bitbucket Pipelines Integration With
***
Bitbucket Pipelines offers a free, automated continuous integration service through Bitbucket cloud servers. With Bitbucket Pipelines, teams can ship their product faster as they could rapidly test their code as soon as they commit. Once the code is tested, Bitbucket Pipeline deploys it into the Production environment automatically. It does so with the help of containers that can be fully customized according to your project requirements.
-LambdaTest integration with Bitbucket Pipelines will help you perform cross browser testing on 3000+ real browsers & browser versions through a Selenium Grid hosted on LambdaTest cloud servers. All you need is to set up your Bitbucket Pipelines with your LambdaTest account & you can trigger tests onto LambdaTest, directly from your Bitbucket Pipelines.
+
integration with Bitbucket Pipelines will help you perform cross browser testing on 3000+ real browsers & browser versions through a Selenium Grid hosted on
cloud servers. All you need is to set up your Bitbucket Pipelines with your
account & you can trigger tests onto
, directly from your Bitbucket Pipelines.
In this topic, you will learn about the:
- Prerequisites
-- Setup to integrate LambdaTest with Bitbucket Pipelines
-- Parallel execution on LambdaTest Selenium Grid
+- Setup to integrate
with Bitbucket Pipelines
+- Parallel execution on
Selenium Grid
## Prerequisites
***
-**Important:** Visit LambdaTest [GitHub repository for Bitbucket Pipelines](https://github.com/qa-repo/protractor-selenium-bitbucket-sample).
+**Important:** Visit
[GitHub repository for Bitbucket Pipelines](https://github.com/qa-repo/protractor-selenium-bitbucket-sample).
- Make sure you have your [Bitbucket Credentials](https://bitbucket.org/dashboard/overview).
-- **LambdaTest Authentication Credentials**
-Be aware of your LambdaTest authentication credentials i.e. your LambdaTest username, access key, and HubURL. You need to set them up as your environment variables. You can retrieve them from your LambdaTest automation dashboard by clicking on the key icon near the help button.
+- **
Authentication Credentials**
+Be aware of your
authentication credentials i.e. your
username, access key, and HubURL. You need to set them up as your environment variables. You can retrieve them from your
automation dashboard by clicking on the key icon near the help button.
- For Linux/Mac:
@@ -74,14 +77,14 @@ Be aware of your LambdaTest authentication credentials i.e. your LambdaTest user
$ set LT_ACCESS_KEY= {YOUR_LAMBDATEST_ACCESS_KEY}
```
-## Integrating LambdaTest With Bitbucket Pipelines
+## Integrating
With Bitbucket Pipelines
***
-**Step 1:** Log in to your Bitbucket account. Go to repositories & import the LambdaTest Git repository for Bitbucket Pipelines. You will be facing the below screen after import is successful.
+**Step 1:** Log in to your Bitbucket account. Go to repositories & import the
Git repository for Bitbucket Pipelines. You will be facing the below screen after import is successful.
.default})
-**Step 2:** After importing the Git repository, fetch the [yml file](https://github.com/qa-repo/protractor-selenium-bitbucket-sample/blob/master/bitbucket-pipelines.yml) to run your automation tests using the Protractor framework on LambdaTest Selenium Grid.
+**Step 2:** After importing the Git repository, fetch the [yml file](https://github.com/qa-repo/protractor-selenium-bitbucket-sample/blob/master/bitbucket-pipelines.yml) to run your automation tests using the Protractor framework on
Selenium Grid.
```
# This is a sample build configuration for JavaScript.
@@ -100,7 +103,7 @@ pipelines:
- npm install
- npm run single
```
-**Step 3:** Now, you need to add LambdaTest environment variables into your Bitbucket pipelines. These environment variables will help to authenticate your test before they are executed on LambdaTest Selenium Grid. Go to **Settings** --> **General** --> **Username aliases** --> **Repository variables**.
+**Step 3:** Now, you need to add
environment variables into your Bitbucket pipelines. These environment variables will help to authenticate your test before they are executed on
Selenium Grid. Go to **Settings** --> **General** --> **Username aliases** --> **Repository variables**.
.default})
@@ -108,7 +111,7 @@ pipelines:
.default})
-**Step 5:** Run the below command to execute a test on LambdaTest Selenium Grid.
+**Step 5:** Run the below command to execute a test on
Selenium Grid.
`npm run single`
@@ -127,9 +130,9 @@ Finished in 7.713 seconds
[10:24:10] I/launcher - chrome67.0 #01 passed
```
-## Running Tests In Parallel On LambdaTest Selenium Grid
+## Running Tests In Parallel On
Selenium Grid
***
-LambdaTest Selenium Grid will help you execute multiple test cases in parallel. You can run a single test scenario over numerous browsers + OS combinations, simultaneously. You can also run different test cases in a similar browser + OS combinations. This would significantly trim down the time taken on your cross browser testing activities.
+
Selenium Grid will help you execute multiple test cases in parallel. You can run a single test scenario over numerous browsers + OS combinations, simultaneously. You can also run different test cases in a similar browser + OS combinations. This would significantly trim down the time taken on your cross browser testing activities.
For running test in parallel, replace the run command from **single** to **parallel** as you update the pipeline’s **yml file**.
@@ -140,7 +143,7 @@ For running test in parallel, replace the run command from **single** to **paral
\ No newline at end of file
+
diff --git a/docs/bitrise-integration-xcuitest.md b/docs/bitrise-integration-xcuitest.md
index c56883878..957496269 100644
--- a/docs/bitrise-integration-xcuitest.md
+++ b/docs/bitrise-integration-xcuitest.md
@@ -1,144 +1,148 @@
----
-id: bitrise-integration-xcuitest
-title: Integrating LambdaTest as a Bitrise CI/CD Step [XCUITest]
-hide_title: true
-sidebar_label: Bitrise - XCUITest
-description: Integrate LambdaTest with Bitrise CI/CD Step [XCUITest] to run your XCUITest workflow successfully on LambdaTest.
-keywords:
-- lambdatest bitrise
-- bitrise with lambdatest
-- manual app testing bitrise
-- xcui testing with bitrise ci
-- xcuitest bitrise
-- app testing with bitrise
-- app automation bitrise
-url: https://www.lambdatest.com/support/docs/bitrise-integration-xcuitest/
-site_name: LambdaTest
-slug: bitrise-integration-xcuitest/
----
-
-
-# Running XCUITests In Bitrise CI
-***
-
-Bitrise offers a mobile CI/CD platform as a service (PaaS) to accelerate the automation of your software development projects. It provides different mobile-first features like exhaustive mobile stack coverage, store code anywhere in cloud or on-premise, and zero hardware setup that make building, testing, and deploying faster and easier.
-
-Using LambdaTest with Bitrise, you can effortlessly perform [XCUI testing](https://www.lambdatest.com/xcuitest-app-testing) of your mobile apps on an [online device farm](https://www.lambdatest.com/online-device-farm) of real Android devices.
-
-## Prerequisites
-***
-
-1. Ensure you have access to LambdaTest [real device cloud](https://www.lambdatest.com/real-device-cloud). If not, please [contact sales](https://www.lambdatest.com/contact-us).
-
-2. A Bitrise account.
-
-3. A GitHub / BitBucket / GitLab or other repository to connect with Bitrise.
-
-:::important Note
-If you are getting started with Bitrise CI, please refer to our documentation on [running Appium tests in Bitrise CI](https://www.lambdatest.com/support/docs/bitrise-integration/).
-:::
-
-## Configuring The LambdaTest App Automate - XCUI Step In Bitrise
-***
-1. Use the search bar to find **LambdaTest App Automate - XCUITest**.
-
-
.default})
-
-2. Click **LambdaTest App Automate- XCUITest** card.
-
-
.default})
-
-
-
-
.default})
-
-3. In **Input Variables**, enter **App ipa path** and **Test suite ipa path**.
-
-> You can add a public link if your files are accessible through public link. In case, you don't an apk link handy, you can use LambdaTest’s sample application Proverbial for running your first test.
-* [Proverbial iOS](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_ios.ipa)
-* [XCUITest Suite](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_ios_xcuitest.ipa)
-
-
.default})
-
-* In **LambdaTest username**, click Select secret variable.
-
-
.default})
-
-4. Provide the list of device and operating system version on which you wish to run your tests.
-
-
.default})
-
-Other options:
-
-| Key | Value | Capability Description
-| -------- | -----| ------------ |
-| Device List | TYPE: STRING
DEFAULT: Untitled
`"iPhone 12-14", "iPhone 6S-13"`| Add the devices here on which the test will be executed.
Devices are comma separated. |
-|Build Name | TYPE: STRING
DEFAULT: Untitled
`iOS Small Run` | You can group your tests like a job containing multiple tests. |
-| Queue Timeout | TYPE: STRING
DEFAULT: 600
`300` | Enter the time in seconds after which you want your build to timeout from queue. |
-| Idle Timeout | TYPE: STRING
DEFAULT: 120
`120` | Enter the time in seconds for maximum running time on a test in the build. |
-| Tunnel | TYPE: BOOLEAN
`True`
OR
`False` | To test local applications with LambdaTest. |
-| Tunnel name | TYPE: STRING
`RabbitHole` | Name of the tunnel. |
-| Device logs | TYPE: BOOLEAN
DEFAULT: FALSE
`True`
OR
`False`| Enable Device Logs that will show information on the actions performed by the device. |
-| Network logs | TYPE: BOOLEAN
DEFAULT: FALSE
`True`
OR
`False` | Enable Network Logs that will show the information on the data transmitted & received by the device. |
-| Video | TYPE: BOOLEAN
DEFAULT: TRUE
`True`
OR
`False` | Video recording of the screen. |
-
-:::info
-
-[XCUI Testing On LambdaTest](https://www.lambdatest.com/support/docs/getting-started-with-xcuitest/#capabilities-supported)
-
-[Automation Capabilities Generator For Selenium and Appium](https://www.lambdatest.com/capabilities-generator/)
-:::
-
-5. Click **⌘ + S** to save the step.
-
-
.default})
-
-6. Let’s go back to the Build and click on `Rebuild` to Build the Step.
-
-
.default})
-
-7. Once the build process is complete, visit **LambdaTest App Automation Dashboard** to view your test results.
-
-
.default})
-
-
\ No newline at end of file
+---
+id: bitrise-integration-xcuitest
+title: Integrating TestMu AI as a Bitrise CI/CD Step [XCUITest]
+hide_title: true
+sidebar_label: Bitrise - XCUITest
+description: Integrate TestMu AI with Bitrise CI/CD Step [XCUITest] to run your XCUITest workflow successfully on TestMu AI.
+keywords:
+- testmu ai bitrise
+- bitrise with testmu ai
+- manual app testing bitrise
+- xcui testing with bitrise ci
+- xcuitest bitrise
+- app testing with bitrise
+- app automation bitrise
+url: https://www.testmuai.com/support/docs/bitrise-integration-xcuitest/
+site_name: TestMu AI
+slug: bitrise-integration-xcuitest/
+canonical: https://www.testmuai.com/support/docs/bitrise-integration-xcuitest/
+---
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+ as a Bitrise CI/CD Step [XCUITest]",
+ "item": `${BRAND_URL}/support/docs/bitrise-integration-xcuitest/`
+ }]
+ })
+ }}
+>
+
+# Running XCUITests In Bitrise CI
+***
+
+Bitrise offers a mobile CI/CD platform as a service (PaaS) to accelerate the automation of your software development projects. It provides different mobile-first features like exhaustive mobile stack coverage, store code anywhere in cloud or on-premise, and zero hardware setup that make building, testing, and deploying faster and easier.
+
+Using
with Bitrise, you can effortlessly perform [XCUI testing](https://www.lambdatest.com/xcuitest-app-testing) of your mobile apps on an [online device farm](https://www.lambdatest.com/online-device-farm) of real Android devices.
+
+## Prerequisites
+***
+
+1. Ensure you have access to
[real device cloud](https://www.lambdatest.com/real-device-cloud). If not, please [contact sales](https://www.lambdatest.com/contact-us).
+
+2. A Bitrise account.
+
+3. A GitHub / BitBucket / GitLab or other repository to connect with Bitrise.
+
+:::important Note
+If you are getting started with Bitrise CI, please refer to our documentation on [running Appium tests in Bitrise CI](/support/docs/bitrise-integration/).
+:::
+
+## Configuring The
App Automate - XCUI Step In Bitrise
+***
+1. Use the search bar to find **
App Automate - XCUITest**.
+
+
.default})
+
+2. Click **
App Automate- XCUITest** card.
+
+
.default})
+
+
+
+
.default})
+
+3. In **Input Variables**, enter **App ipa path** and **Test suite ipa path**.
+
+> You can add a public link if your files are accessible through public link. In case, you don't an apk link handy, you can use
’s sample application Proverbial for running your first test.
+* [Proverbial iOS](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_ios.ipa)
+* [XCUITest Suite](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_ios_xcuitest.ipa)
+
+
.default})
+
+* In **
username**, click Select secret variable.
+
+
.default})
+
+4. Provide the list of device and operating system version on which you wish to run your tests.
+
+
.default})
+
+Other options:
+
+| Key | Value | Capability Description
+| -------- | -----| ------------ |
+| Device List | TYPE: STRING
DEFAULT: Untitled
`"iPhone 12-14", "iPhone 6S-13"`| Add the devices here on which the test will be executed.
Devices are comma separated. |
+|Build Name | TYPE: STRING
DEFAULT: Untitled
`iOS Small Run` | You can group your tests like a job containing multiple tests. |
+| Queue Timeout | TYPE: STRING
DEFAULT: 600
`300` | Enter the time in seconds after which you want your build to timeout from queue. |
+| Idle Timeout | TYPE: STRING
DEFAULT: 120
`120` | Enter the time in seconds for maximum running time on a test in the build. |
+| Tunnel | TYPE: BOOLEAN
`True`
OR
`False` | To test local applications with
. |
+| Tunnel name | TYPE: STRING
`RabbitHole` | Name of the tunnel. |
+| Device logs | TYPE: BOOLEAN
DEFAULT: FALSE
`True`
OR
`False`| Enable Device Logs that will show information on the actions performed by the device. |
+| Network logs | TYPE: BOOLEAN
DEFAULT: FALSE
`True`
OR
`False` | Enable Network Logs that will show the information on the data transmitted & received by the device. |
+| Video | TYPE: BOOLEAN
DEFAULT: TRUE
`True`
OR
`False` | Video recording of the screen. |
+
+:::info
+
+[XCUI Testing On
](/support/docs/getting-started-with-xcuitest/#capabilities-supported)
+
+[Automation Capabilities Generator For Selenium and Appium](https://www.lambdatest.com/capabilities-generator/)
+:::
+
+5. Click **⌘ + S** to save the step.
+
+
.default})
+
+6. Let’s go back to the Build and click on `Rebuild` to Build the Step.
+
+
.default})
+
+7. Once the build process is complete, visit **
App Automation Dashboard** to view your test results.
+
+
.default})
+
+
+
diff --git a/docs/bitrise-integration.md b/docs/bitrise-integration.md
index b611abd66..0997a2bb4 100644
--- a/docs/bitrise-integration.md
+++ b/docs/bitrise-integration.md
@@ -3,19 +3,22 @@ id: appium-bitrise
title: How to integrate your Appium tests with Bitrise
hide_title: true
sidebar_label: Bitrise - Appium
-description: Integrate LambdaTest with Bitrise CI to get started with Appium app automation across a wide range of real Android and iOS devices.
+description: Integrate TestMu AI with Bitrise CI to get started with Appium app automation across a wide range of real Android and iOS devices.
keywords:
-- lambdatest bitrise
-- bitrise with lambdatest
+- testmu ai bitrise
+- bitrise with testmu ai
- manual app testing bitrise
- appium testing with bitrise ci
- appium bitrise
- app testing with bitrise
- app automation bitrise
-url: https://www.lambdatest.com/support/docs/bitrise-integration/
-site_name: LambdaTest
+url: https://www.testmuai.com/support/docs/bitrise-integration/
+site_name: TestMu AI
slug: bitrise-integration/
+canonical: https://www.testmuai.com/support/docs/bitrise-integration/
---
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
with Bitrise, you can effortlessly perform [Appium testing](https://www.lambdatest.com/appium-mobile-testing) of your mobile apps on an [online device farm](https://www.lambdatest.com/online-device-farm) of 3000+ real devices and OS versions.
## Prerequisites
***
-1. Ensure you have access to LambdaTest [real device cloud](https://www.lambdatest.com/real-device-cloud). If not, please [contact sales](https://www.lambdatest.com/contact-us).
+1. Ensure you have access to
[real device cloud](https://www.lambdatest.com/real-device-cloud). If not, please [contact sales](https://www.lambdatest.com/contact-us).
2. A Bitrise account.
@@ -136,7 +139,7 @@ Your app build will now trigger and start running.
.default})
-3. A search steps box will appear. Enter *LambdaTest Upload* and click LambdaTest Upload card.
+3. A search steps box will appear. Enter *
Upload* and click
Upload card.
.default})
@@ -146,19 +149,19 @@ Your app build will now trigger and start running.
.default})
-* In **LambdaTest username**, click Select secret variable.
+* In **
username**, click Select secret variable.
.default})
-* Enter the key (it can be anything), your LambdaTest username and click **Add new**.
+* Enter the key (it can be anything), your
username and click **Add new**.
.default})
-* In **LambdaTest access key**, click Select secret variable.
+* In **
access key**, click Select secret variable.
.default})
-* Enter the key (it can be anything), your LambdaTest access key and click **Add new**.
+* Enter the key (it can be anything), your
access key and click **Add new**.
.default})
@@ -186,7 +189,7 @@ You'll be taken to the build interface as shown below.
.default})
-8. Scroll down and click on three dots adjacent to the LambdaTest icon.
+8. Scroll down and click on three dots adjacent to the
icon.
.default})
@@ -196,4 +199,4 @@ You'll be taken to the build interface as shown below.
You're done! With this App URL, you can now perform Mobile App Automation. This app will also be available under **Real Time Testing > Real Time > App Testing** in the uploaded apps section.
-
.default})
\ No newline at end of file
+
.default})
diff --git a/docs/breeze-integration.md b/docs/breeze-integration.md
index 16f7a056c..8f7c8bfb8 100644
--- a/docs/breeze-integration.md
+++ b/docs/breeze-integration.md
@@ -3,20 +3,23 @@ id: breeze-integration
title: Breeze Integration
hide_title: true
sidebar_label: Breeze
-description: LambdaTest integration with Breeze will help you log UI bugs or observations in your Breeze project as you perform cross browser testing on LambdaTest.
+description: TestMu AI integration with Breeze will help you log UI bugs or observations in your Breeze project as you perform cross browser testing on TestMu AI.
keywords:
- - lambdatest-breeze integration
+ - testmu ai-breeze integration
- easy bug tracking
- project management tool
- issue tracking tool
- - lambdatest app marketplace
- - lambdatest integrations
+ - testmu ai app marketplace
+ - testmu ai integrations
- one click bug marking
- - lambdatest 3rd party integration
-url: https://www.lambdatest.com/support/docs/breeze-integration-with-lambdatest/
-site_name: LambdaTest
-slug: breeze-integration-with-lambdatest/
+ - testmu ai 3rd party integration
+url: https://www.testmuai.com/support/docs/breeze-integration-with-testmu/
+site_name: TestMu AI
+slug: breeze-integration-with-testmu/
+canonical: https://www.testmuai.com/support/docs/breeze-integration-with-testmu/
---
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
integration with Breeze will help you log UI bugs or observations in your Breeze project as you perform [cross browser testing](https://www.lambdatest.com) on
. You can capture a screenshot of your website over a browser discrepancy, highlight the UI bug, report that bug to your colleague, provide a summary of the issue, all from the middle of your test-session at
. All of the details that you may mention around a bug would be auto-populated in your respective Breeze project.
-## How To Integrate Breeze With Your LambdaTest Account?
+## How To Integrate Breeze With Your
Account?
***
-**Step 1:** Login to your LambdaTest account. You would need to have Admin or User level access to see and install integrations.
+**Step 1:** Login to your
account. You would need to have Admin or User level access to see and install integrations.
-**Step 2:** Select ‘Integration’ from the left navigation menu bar. This will guide you to a screen where you will find a list of 3rd party applications, available to integrate with your LambdaTest account.
+**Step 2:** Select ‘Integration’ from the left navigation menu bar. This will guide you to a screen where you will find a list of 3rd party applications, available to integrate with your
account.
**Step 3:** Click on ‘Add’ under the block that says ‘Breeze’.
.default})
-**Step 4:** You need to specify your API token for authenticating your LambdaTest account to your Breeze instance.
+**Step 4:** You need to specify your API token for authenticating your
account to your Breeze instance.
.default})
@@ -75,13 +78,13 @@ LambdaTest integration with Breeze will help you log UI bugs or observations in
When two different applications interact with each other, a server-to-server communication is established. API token is needed for authenticating user identity from one server to another, by fetching user-owned resources available on the server from where the communication is initiated. API token has been a necessity for maintaining security and data integrity of any application. They are just as vital to an end user as they are to an application. API tokens are relevant if an end user logs in an application through a 2-step verification process.
**Important Note:** It is always a best practice to never share your API tokens, as someone else could authenticate a third-party application on your behalf and misuse it. In case you feel your API token for Breeze project is misplaced then don’t worry! Breeze allows your the option to regenerate the API token.
-**Step 7:** Paste this API token while integrating Breeze from your LambdaTest account. Now, hit the Install button.
+**Step 7:** Paste this API token while integrating Breeze from your
account. Now, hit the Install button.
.default})
-**Step 8:** Kudos! You have successfully integrated your LambdaTest account with Breeze your project.
+**Step 8:** Kudos! You have successfully integrated your
account with Breeze your project.
-## Log Your First Bug Through LambdaTest Integration With Breeze
+## Log Your First Bug Through
Integration With Breeze
***
**Step 1:** Go for any of the test from the left navigation menu. For demo, we will be taking "Real Time Test" option.
@@ -115,36 +118,36 @@ When two different applications interact with each other, a server-to-server com
.default})
-**Step 6:** Now, go to your Breeze project and you will notice your logged task under the specific list your assigned it through LambdaTest.
+**Step 6:** Now, go to your Breeze project and you will notice your logged task under the specific list your assigned it through
.
.default})
-**Step 7:** As you click on the task. You will be able to find all the details you provided while marking the bug through LambdaTest. You would also find a URL routing to the screenshot you captured while cross browser testing using LambdaTest.
+**Step 7:** As you click on the task. You will be able to find all the details you provided while marking the bug through
. You would also find a URL routing to the screenshot you captured while cross browser testing using
.
-## Remove LambdaTest Integration With Breeze
+## Remove
Integration With Breeze
***
> You can work with one integration at a time. So if you would want to integrate to a similar 3rd party application, then you would have to remove your current integration. Here is how you can do that.
-**Step 1:** Login to your LambdaTest account.
+**Step 1:** Login to your
account.
-**Step 2:** Select ‘Integrations’ from the left-navigation menu. This will guide you to a screen where you will find 3rd party applications, available to integrate with your LambdaTest account.
+**Step 2:** Select ‘Integrations’ from the left-navigation menu. This will guide you to a screen where you will find 3rd party applications, available to integrate with your
account.
**Step 3:** Click on ‘REMOVE’. You can find the remove button right under the ‘Breeze’ block which would be highlighted with a green tick.
.default})
-> That was all you need to know for LambdaTest + Breeze Integration. Increase your productivity with our integrations. If you still have any questions for us, please feel free to let us know. Our experts are always available on
window.openLTChatWidget()}>**chat** to help you out with any roadblock regarding our product. Happy testing! 🙂
+> That was all you need to know for
+ Breeze Integration. Increase your productivity with our integrations. If you still have any questions for us, please feel free to let us know. Our experts are always available on
window.openLTChatWidget()}>**chat** to help you out with any roadblock regarding our product. Happy testing! 🙂
\ No newline at end of file
+
diff --git a/docs/browser-cloud-api-reference.md b/docs/browser-cloud-api-reference.md
new file mode 100644
index 000000000..e6ebbe7b4
--- /dev/null
+++ b/docs/browser-cloud-api-reference.md
@@ -0,0 +1,129 @@
+---
+id: browser-cloud-api-reference
+title: API Reference - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: API Reference
+description: REST API reference for TestMu AI Browser Cloud. Planned endpoints for sessions, context, profiles, files, extensions, quick actions, and tunnels.
+keywords:
+ - browser cloud api
+ - rest api browser cloud
+ - browser cloud endpoints
+ - api reference
+url: https://www.testmuai.com/support/docs/browser-cloud-api-reference/
+site_name: TestMu AI
+slug: browser-cloud-api-reference/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-api-reference/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# API Reference (Coming Soon)
+
+The REST API will expose all TestMu AI Browser SDK capabilities over HTTP, making
+
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
+```
+
+
diff --git a/docs/browser-cloud-connect.md b/docs/browser-cloud-connect.md
new file mode 100644
index 000000000..56d31da29
--- /dev/null
+++ b/docs/browser-cloud-connect.md
@@ -0,0 +1,455 @@
+---
+id: browser-cloud-connect
+title: Connect to a Session - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Connect to a Session
+description: Drive TestMu AI Browser Cloud sessions using Puppeteer, Playwright, or Selenium.
+keywords:
+ - browser cloud connect
+ - puppeteer cloud browser
+ - playwright cloud browser
+ - selenium cloud browser
+ - browser automation adapter
+url: https://www.testmuai.com/support/docs/connect-to-session/
+site_name: TestMu AI
+slug: connect-to-session/
+canonical: https://www.testmuai.com/support/docs/connect-to-session/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+
+# Connect to a Session
+
+Connect to a cloud browser session and control it with Puppeteer, Playwright, or Selenium. All three adapters connect to the same
Browser Cloud infrastructure - pick the one that matches your existing test framework.
+
+| | Puppeteer | Playwright | Selenium |
+|---|---|---|---|
+| **Connection** | WebSocket (CDP) | WebSocket (CDP) | HTTP (WebDriver) |
+| **Stealth** | Best | Good | Coming Soon |
+| **Return type** | `Browser` | `{ browser, context, page }` | `WebDriver` |
+| **Humanized interactions** | `click`, `type` | `click`, `type`, `fill` | Coming Soon |
+| **Auto-waiting** | Manual | Built-in | Manual |
+| **Profile persistence** | Yes | Yes | Yes |
+
+**Our recommendation:** Start with **Puppeteer** for most agent use cases. It
+has the best stealth support and the simplest return type. Switch to
+**Playwright** if you need auto-waiting or `page.fill()`. Use **Selenium** if
+you have an existing Selenium test suite you want to run on the cloud.
+
+## Before You Begin
+
+Make sure you have completed the following before connecting to a session:
+
+- **TestMu AI Browser SDK installed** - Run `npm install @testmuai/browser-cloud` if you have not already.
+- **Session credentials configured** - Set your `LT_USERNAME` and `LT_ACCESS_KEY` environment variables.
+- **Quickstart completed** - If this is your first time using
Browser Cloud, [launch your first session](/support/docs/launch-first-session/) first.
+
+---
+
+## Basic Usage
+
+### Puppeteer
+
+Most Puppeteer scripts start with `puppeteer.launch()` to launch a local
+browser. With the TestMu AI Browser SDK, you replace that with
+`client.puppeteer.connect()` to connect to a cloud browser instead. Your
+subsequent Puppeteer calls work exactly the same as before.
+
+```typescript
+import { Browser } from '@testmuai/browser-cloud';
+
+const client = new Browser();
+
+// 1. Create a cloud session
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ lambdatestOptions: {
+ build: 'My Agent',
+ name: 'Puppeteer Session',
+ 'LT:Options': {
+ username: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ }
+ }
+});
+
+// 2. Connect - returns a standard Puppeteer Browser object
+const browser = await client.puppeteer.connect(session);
+const page = (await browser.pages())[0];
+
+// 3. Use Puppeteer as normal
+await page.goto('https://example.com');
+await page.screenshot({ path: 'screenshot.png' });
+
+// 4. Clean up
+await browser.close();
+await client.sessions.release(session.id);
+```
+
+The `browser` object returned by `client.puppeteer.connect()` is a standard
+Puppeteer `Browser`. Use it exactly as you would with plain Puppeteer - all
+existing Puppeteer knowledge applies.
+
+### Playwright
+
+Like Puppeteer, the main change is how you connect - replacing
+`chromium.launch()` with `client.playwright.connect()`.
+
+:::note
+Playwright requires **Node.js 18+**. If you see a version error,
+upgrade with `nvm install 18 && nvm use 18`.
+:::
+
+```typescript
+import { Browser } from '@testmuai/browser-cloud';
+
+const client = new Browser();
+
+const session = await client.sessions.create({
+ adapter: 'playwright',
+ lambdatestOptions: {
+ build: 'My Agent',
+ name: 'Playwright Session',
+ 'LT:Options': {
+ username: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ }
+ }
+});
+
+// Returns browser, context, AND page - all three ready to use
+const { browser, context, page } = await client.playwright.connect(session);
+
+await page.goto('https://example.com');
+await page.screenshot({ path: 'screenshot.png' });
+
+await browser.close();
+await client.sessions.release(session.id);
+```
+
+Notice the key difference from Puppeteer: `client.playwright.connect()` returns
+three objects - `browser`, `context`, and `page` - instead of just a browser.
+These are standard Playwright objects. Use them exactly as you would with plain
+Playwright.
+
+### Selenium
+
+Selenium connects to
differently from Puppeteer and Playwright.
+Instead of WebSocket, it uses the standard **WebDriver protocol over HTTP**,
+connecting to
's Selenium Hub.
+
+```typescript
+import { Browser } from '@testmuai/browser-cloud';
+
+const client = new Browser();
+
+const session = await client.sessions.create({
+ adapter: 'selenium',
+ lambdatestOptions: {
+ build: 'My Agent',
+ name: 'Selenium Session',
+ 'LT:Options': {
+ username: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ }
+ }
+});
+
+// Returns a standard Selenium WebDriver
+const driver = await client.selenium.connect(session);
+
+await driver.get('https://example.com');
+const title = await driver.getTitle();
+console.log('Title:', title);
+
+await driver.quit();
+await client.sessions.release(session.id);
+```
+
+The `driver` object is a standard Selenium `WebDriver`. Use it exactly as you
+would with plain `selenium-webdriver`.
+
+---
+
+## What the SDK Does for You
+
+
+
+
+When you call `client.puppeteer.connect(session)`, the SDK handles several
+things automatically based on your session configuration:
+
+1. **Stealth check.** If `stealthConfig` is present and `skipFingerprintInjection` is not set, the SDK connects via `puppeteer-extra` with the stealth plugin - which patches 15+ browser fingerprints automatically.
+
+2. **User-agent.** If `randomizeUserAgent` is enabled, a random realistic user-agent is set on the page.
+
+3. **Viewport.** If `randomizeViewport` is enabled, ±20px random jitter is added to the viewport dimensions.
+
+4. **Humanized interactions.** If `humanizeInteractions` is true, `page.click()` and `page.type()` are monkey-patched to add random delays that mimic human behavior.
+
+5. **Profile loading.** If `profileId` is set, saved cookies are loaded from disk. And when you call `browser.close()`, the profile is automatically saved with the current cookies.
+
+
+
+
+When you call `client.playwright.connect(session)`:
+
+1. **Connects** to cloud via `chromium.connect`
+2. **Gets or creates** a `BrowserContext` and `Page`
+3. **Injects stealth scripts** (if enabled) via `page.addInitScript()` - these run before any page JavaScript:
+ - Hides `navigator.webdriver`
+ - Fakes `chrome.runtime` (simulates extensions presence)
+ - Fakes `navigator.plugins` (3 standard Chrome plugins)
+ - Sets `navigator.languages = ['en-US', 'en']`
+ - Patches `permissions.query` for notifications
+ - Spoofs WebGL vendor/renderer
+4. **Auto-applies stealth** to new pages via `context.on('page')`
+5. **Patches interactions** (if humanize enabled) - `page.click()`, `page.type()`, and `page.fill()` get random delays
+6. **Loads/saves profile** (if `profileId` set)
+
+
+
+
+When you call `client.selenium.connect(session)`:
+
+1. **Connects** to the Selenium Hub at `https://hub.lambdatest.com/wd/hub` via HTTP
+2. **Reads** `LT_USERNAME` and `LT_ACCESS_KEY` from your environment variables
+3. **Builds** W3C capabilities from your session config
+4. **Connects** over the standard WebDriver protocol
+
+The Selenium adapter **ignores** `session.websocketUrl` and builds its own connection.
+
+
+
+
+---
+
+## Adding Session Features
+
+```typescript
+const session = await client.sessions.create({
+ adapter: 'puppeteer', // or 'playwright' or 'selenium'
+ stealthConfig: { // Anti-bot detection
+ humanizeInteractions: true,
+ randomizeUserAgent: true,
+ },
+ profileId: 'my-app-login', // Persist auth state
+ tunnel: true, // Access localhost
+ timeout: 600000, // 10-minute timeout
+ lambdatestOptions: { ... }
+});
+```
+
+---
+
+## Full Working Example
+
+
+
+
+A complete script that creates a session, scrapes a page title, and cleans up
+with proper error handling:
+
+```typescript
+import { Browser } from '@testmuai/browser-cloud';
+
+const client = new Browser();
+
+async function main() {
+ const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ lambdatestOptions: {
+ build: 'Agent Scripts',
+ name: 'Scrape Example',
+ 'LT:Options': {
+ username: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ }
+ }
+ });
+
+ console.log(`View session: ${session.sessionViewerUrl}`);
+
+ try {
+ const browser = await client.puppeteer.connect(session);
+ const page = (await browser.pages())[0];
+
+ await page.goto('https://news.ycombinator.com');
+ const title = await page.title();
+ console.log('Page title:', title);
+
+ await browser.close();
+ } finally {
+ await client.sessions.release(session.id);
+ }
+}
+
+main().catch(console.error);
+```
+
+
+
+
+A complete script that creates a session, scrapes a page title, and cleans up
+with proper error handling:
+
+```typescript
+import { Browser } from '@testmuai/browser-cloud';
+
+const client = new Browser();
+
+async function main() {
+ const session = await client.sessions.create({
+ adapter: 'playwright',
+ lambdatestOptions: {
+ build: 'Agent Scripts',
+ name: 'Scrape Example',
+ 'LT:Options': {
+ username: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ }
+ }
+ });
+
+ console.log(`View session: ${session.sessionViewerUrl}`);
+
+ try {
+ const { browser, context, page } = await client.playwright.connect(session);
+
+ await page.goto('https://news.ycombinator.com');
+ const title = await page.title();
+ console.log('Page title:', title);
+
+ await browser.close();
+ } finally {
+ await client.sessions.release(session.id);
+ }
+}
+
+main().catch(console.error);
+```
+
+
+
+
+A complete script that creates a session, scrapes a page title, and cleans up
+with proper error handling:
+
+```typescript
+import { Browser } from '@testmuai/browser-cloud';
+
+const client = new Browser();
+
+async function main() {
+ const session = await client.sessions.create({
+ adapter: 'selenium',
+ lambdatestOptions: {
+ build: 'Agent Scripts',
+ name: 'Scrape Example',
+ 'LT:Options': {
+ username: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ }
+ }
+ });
+
+ console.log(`View session: ${session.sessionViewerUrl}`);
+
+ try {
+ const driver = await client.selenium.connect(session);
+
+ await driver.get('https://news.ycombinator.com');
+ const title = await driver.getTitle();
+ console.log('Page title:', title);
+
+ await driver.quit();
+ } finally {
+ await client.sessions.release(session.id);
+ }
+}
+
+main().catch(console.error);
+```
+
+
+
+
+:::warning
+Sessions remain active until explicitly released or timed out.
+Always call `client.sessions.release()` when finished instead of waiting for
+the timeout.
+:::
+
+---
+
+## When to Choose
+
+| Use Case | Recommended | Why |
+|----------|-------------|-----|
+| General agent automation | Puppeteer | Mature, well-documented, large ecosystem |
+| Stealth-heavy tasks | Puppeteer | Best stealth plugin support (`puppeteer-extra-plugin-stealth`) |
+| Complex form interactions | Playwright | Built-in `page.fill()` method |
+| Auto-waiting | Playwright | Automatically waits for elements before interacting |
+| Multi-page workflows | Playwright | Better context management for complex navigation |
+| Existing Selenium test suite | Selenium | Minimal migration - same WebDriver API |
+| Simple return type | Puppeteer | Returns a single `Browser` object (vs Playwright's 3 objects) |
+
+---
+
+
+
+
diff --git a/docs/browser-cloud-context.md b/docs/browser-cloud-context.md
new file mode 100644
index 000000000..8a873d96b
--- /dev/null
+++ b/docs/browser-cloud-context.md
@@ -0,0 +1,214 @@
+---
+id: browser-cloud-context
+title: Reusing Context & Auth - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Transfer Cookies & Storage
+description: Extract and inject browser state across sessions to preserve login and user data in TestMu AI Browser Cloud.
+keywords:
+ - browser cloud context
+ - session context
+ - browser authentication
+ - cookies persistence
+ - session state management
+url: https://www.testmuai.com/support/docs/browser-cloud-context/
+site_name: TestMu AI
+slug: browser-cloud-context/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-context/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Transfer Cookies and Storage Between Sessions
+
+Extract and inject browser state - cookies, localStorage, and sessionStorage - across sessions to preserve login and user data without re-authenticating.
+
+
+## Why You Need This
+
+Your agent needs to stay logged in across sessions. Without a way to preserve
+authentication state, every new session starts from scratch - your agent has to
+repeat the login flow each time. That wastes time, risks triggering security
+alerts from frequent logins, breaks on MFA prompts, and burns LLM tokens if
+your agent uses AI to navigate login pages.
+
+The Context Service solves this. It captures everything the browser remembers
+about a user's session - login cookies, user preferences in localStorage,
+shopping cart data in sessionStorage - and lets you inject that state into a
+new session. Your agent logs in once, saves the context, and skips login
+entirely in every future session.
+
+```typescript
+interface SessionContext {
+ cookies?: Cookie[];
+ localStorage?: Record
>;
+ sessionStorage?: Record>;
+}
+```
+
+## Before You Begin
+
+You need an active session with a connected page before you can extract or
+inject context. If you have not set that up yet, see
+[Connect to a session](/support/docs/connect-to-session/).
+
+
+## Framework Agnostic
+
+The Context Service auto-detects whether you pass a Puppeteer `Page` or a
+Playwright `Page`/`BrowserContext`. The same API works with both - you never
+need to specify which adapter you're using.
+
+
+## Extracting Context
+
+Get all browser state from a page:
+
+```typescript
+const context = await client.context.getContext(page);
+
+context.cookies; // Array of cookies
+context.localStorage; // { "origin": { "key": "value" } }
+context.sessionStorage; // { "origin": { "key": "value" } }
+```
+
+Or extract individual parts:
+
+```typescript
+const cookies = await client.context.getCookies(page);
+const localStorage = await client.context.getLocalStorage(page);
+const sessionStorage = await client.context.getSessionStorage(page);
+```
+
+
+## Injecting Context
+
+Set browser state on a new page:
+
+```typescript
+await client.context.setContext(page, {
+ cookies: [
+ { name: 'session_id', value: 'abc123', domain: '.example.com', path: '/' }
+ ],
+ localStorage: {
+ 'https://example.com': { theme: 'dark', lang: 'en' }
+ },
+});
+```
+
+Or set individual parts:
+
+```typescript
+await client.context.setCookies(page, cookies);
+await client.context.setLocalStorage(page, localStorageData);
+await client.context.setSessionStorage(page, sessionStorageData);
+```
+
+
+## Clearing Context
+
+```typescript
+await client.context.clearContext(page); // Clear everything
+await client.context.clearCookies(page); // Just cookies
+await client.context.clearStorage(page); // localStorage + sessionStorage
+```
+
+
+## Example: Transfer Login Between Sessions
+
+The most common use case - log in once, reuse the auth state:
+
+```typescript
+// Session 1: Log in and capture
+const session1 = await client.sessions.create({ adapter: 'puppeteer', ... });
+const browser1 = await client.puppeteer.connect(session1);
+const page1 = (await browser1.pages())[0];
+
+await page1.goto('https://app.example.com/login');
+await page1.type('#email', 'user@example.com');
+await page1.type('#password', 'password');
+await page1.click('#login-button');
+await page1.waitForNavigation();
+
+const savedContext = await client.context.getContext(page1);
+await browser1.close();
+await client.sessions.release(session1.id);
+
+// Session 2: Skip login entirely
+const session2 = await client.sessions.create({ adapter: 'puppeteer', ... });
+const browser2 = await client.puppeteer.connect(session2);
+const page2 = (await browser2.pages())[0];
+
+await client.context.setContext(page2, savedContext);
+await page2.goto('https://app.example.com/dashboard');
+// Already logged in!
+```
+
+
+## How It Works
+
+- **Puppeteer:** Uses CDP `Network.getAllCookies` / `Network.setCookie` for cookies, and `page.evaluate()` for localStorage/sessionStorage
+- **Playwright:** Uses `context.cookies()` / `context.addCookies()` for cookies, and `page.evaluate()` for storage
+- Framework detection is automatic based on the page object's available methods
+
+
+## Context vs Profiles
+
+The Context Service transfers state **within a single script run** (in memory).
+If you need state to persist **across separate script runs** (on disk), use the
+[Profiles for persistent state](/support/docs/browser-cloud-profiles/) instead.
+
+
+
+
diff --git a/docs/browser-cloud-debugging.md b/docs/browser-cloud-debugging.md
new file mode 100644
index 000000000..0faffe94f
--- /dev/null
+++ b/docs/browser-cloud-debugging.md
@@ -0,0 +1,196 @@
+---
+id: browser-cloud-debugging
+title: Debugging & Observability - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Replay and Debug Sessions
+description: Watch, replay, and debug your agent's browser sessions with video recordings, console logs, and network capture.
+keywords:
+ - browser cloud debugging
+ - session recording
+ - browser cloud logs
+ - session observability
+ - troubleshooting browser cloud
+url: https://www.testmuai.com/support/docs/browser-cloud-debugging/
+site_name: TestMu AI
+slug: browser-cloud-debugging/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-debugging/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Replay and Debug Sessions
+
+Watch, replay, and troubleshoot your agent's browser sessions. Every session automatically records video, console logs, and network requests - accessible from the TestMu AI dashboard.
+
+
+## Built-In Observability
+
+When your agent runs at 3am and does something unexpected, you need to know
+exactly what happened. Every session runs on TestMu AI's infrastructure,
+which means every session automatically comes with video recordings, console
+logs, and network request capture - no extra setup required.
+
+
+## TestMu AI Web Automation Dashboard
+
+Every session appears on the TestMu AI Web Automation Dashboard:
+
+```
+https://automation.lambdatest.com/logs/
+```
+
+From the dashboard you can:
+
+- Watch **live video** of the browser as your agent interacts with it
+- **Replay** recorded sessions after they complete
+- View captured **console logs**
+- Inspect **network requests**
+- Review **screenshots**
+- Check **test results** (pass/fail)
+
+
+## Organizing Sessions
+
+Use `build` and `name` in `lambdatestOptions` to organize sessions on the
+dashboard. This is especially helpful when running multiple agents or scenarios:
+
+```typescript
+const session = await client.sessions.create({
+ lambdatestOptions: {
+ build: 'Price Monitor Agent - v2.1',
+ name: 'Extract Competitor Pricing - Amazon',
+ 'LT:Options': {
+ username: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ video: true, // Record video
+ console: true, // Capture console logs,
+ }
+ }
+});
+```
+
+
+## Debug URLs
+
+Every session provides URLs for viewing:
+
+```typescript
+console.log(session.debugUrl); // Dashboard URL for this session
+console.log(session.sessionViewerUrl); // Live stream of the browser
+```
+
+
+## SDK Console Output
+
+The SDK logs connection steps and actions to stdout:
+
+```
+Adapter: Connecting to session session_123_abc via Puppeteer...
+Adapter: Set stealth user-agent: Mozilla/5.0 (Windows NT 10.0...
+Adapter: Set stealth viewport: 1907x1063
+Adapter: Humanized interactions enabled
+Adapter: Loading profile my-app-login
+```
+
+
+## Common Issues
+
+Here are the most common issues and how to fix them.
+
+**Connection Timeout**
+
+```
+Error: Timed out after 30000ms while waiting for the WebSocket
+```
+
+Causes: Invalid `LT_USERNAME` or `LT_ACCESS_KEY`, TestMu AI service outage,
+or network firewall blocking WebSocket connections.
+
+Fix: Verify your credentials, check the TestMu AI status page, try a different
+network.
+
+
+**Session Not Found**
+
+```
+Session session_xyz not found
+```
+
+Cause: Session was already released or timed out. The default timeout is 5
+minutes.
+
+Fix: Increase with `timeout: 600000` (10 minutes) in your session config.
+
+
+**Playwright Requires Node 18+**
+
+```
+Playwright requires Node.js 18 or higher.
+```
+
+Fix: Upgrade Node.js with `nvm install 18 && nvm use 18`.
+
+
+**Profile Not Loading**
+
+Cause: On the first run, there's no saved profile yet.
+
+Fix: This is normal. The profile is created when `browser.close()` is called.
+Subsequent runs will load it.
+
+
+
+
+
diff --git a/docs/browser-cloud-extensions.md b/docs/browser-cloud-extensions.md
new file mode 100644
index 000000000..779f55d0d
--- /dev/null
+++ b/docs/browser-cloud-extensions.md
@@ -0,0 +1,152 @@
+---
+id: browser-cloud-extensions
+title: Extensions - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Load Chrome Extensions
+description: Load Chrome extensions into TestMu AI Browser Cloud sessions.
+keywords:
+ - browser cloud extensions
+ - chrome extensions cloud
+ - browser extension automation
+ - load extensions cloud browser
+url: https://www.testmuai.com/support/docs/browser-cloud-extensions/
+site_name: TestMu AI
+slug: browser-cloud-extensions/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-extensions/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Load Chrome Extensions
+
+Install Chrome extensions into cloud browser sessions so they behave identically to local browsers with your required extensions.
+
+
+## Overview
+
+Your agent workflow depends on a Chrome extension - an ad blocker, a cookie manager, or a custom tool your team built. Without it, the browser behaves differently and your automation may not work as expected.
+
+The Extension Service solves this by letting you register Chrome extensions and inject them into Browser Cloud sessions. You provide a cloud-hosted URL (S3) for each extension, and downloads and installs it into the browser instance when the session starts. Your cloud sessions behave the same way as your local browser.
+
+:::note Before You Begin
+Your extension must be hosted at a cloud URL (such as an S3 bucket) before you can register it. See [Current Limitations](#current-limitations) for details on what is supported today.
+:::
+
+
+## Loading Extensions into a Session
+
+First, register an extension. Then pass its ID when creating a session:
+
+```typescript
+// Step 1: Register (one time)
+const ext = await client.extensions.register({
+ name: 'My Extension',
+ version: '1.0.0',
+ cloudUrl: 'https://s3.amazonaws.com/bucket/extension.zip',
+});
+
+// Step 2: Load into sessions
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ extensionIds: [ext.id], // Pass registered extension IDs
+ lambdatestOptions: { ... }
+});
+```
+
+When `extensionIds` are provided, the session manager fetches the cloud URLs
+and adds them to capabilities as `lambda:loadExtension`.
+
+
+## Managing Extensions
+
+```typescript
+const extensions = await client.extensions.list();
+
+const ext = await client.extensions.get('ext_abc123');
+
+await client.extensions.delete('ext_abc123');
+```
+
+
+## Extension Object
+
+```typescript
+interface Extension {
+ id: string;
+ name: string;
+ version: string;
+ description?: string;
+ enabled: boolean;
+ createdAt: string;
+ cloudUrl?: string; // S3 URL
+ localPath?: string; // Local file path
+}
+```
+
+## Supported Formats
+
+- `.zip` archives containing Chrome extension files
+- `.crx` Chrome extension packages
+
+
+## Current Limitations
+
+- Extension upload to S3 must be done manually (via curl, AWS CLI, or your upload pipeline)
+- The automated upload API through is not yet integrated
+- Extensions only work with cloud sessions
+
+
+
+
diff --git a/docs/browser-cloud-files.md b/docs/browser-cloud-files.md
new file mode 100644
index 000000000..8282725c4
--- /dev/null
+++ b/docs/browser-cloud-files.md
@@ -0,0 +1,157 @@
+---
+id: browser-cloud-files
+title: Files - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Upload and Download Files
+description: Upload, download, and manage files within cloud browser sessions in TestMu AI Browser Cloud.
+keywords:
+ - browser cloud files
+ - file upload cloud browser
+ - file download cloud browser
+ - file transfer automation
+ - browser file service
+url: https://www.testmuai.com/support/docs/browser-cloud-files/
+site_name: TestMu AI
+slug: browser-cloud-files/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-files/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Upload and Download Files
+
+Transfer files between your local machine and cloud browser sessions. Handle document uploads, file exports, and downloads without external storage services.
+
+
+## Why You Need This
+
+Your agent is filling out a government form that requires a document upload. The
+form is running in a cloud browser, but the document is on your local machine.
+Or your agent triggers a CSV download inside the cloud browser - a report, an
+export, a receipt - and you need that file locally.
+
+The File Service bridges the gap. It transfers files between your local machine
+and a remote cloud browser on Browser Cloud - without needing
+external storage services like S3 or GCS. Files are sent directly through the
+browser's page context using Base64 encoding.
+
+
+## Upload a File to the Cloud Browser
+
+```typescript
+const fileBuffer = fs.readFileSync('document.pdf');
+await client.files.uploadToSession(session.id, fileBuffer, 'document.pdf');
+```
+
+**How it works:** The buffer is Base64-encoded, sent to the cloud browser via
+`page.evaluate()`, decoded in the browser, and set on the file input element.
+
+
+## Download a File from the Cloud Browser
+
+**By URL:**
+
+```typescript
+const result = await client.files.downloadFromSession(
+ session.id,
+ 'https://example.com/report.csv'
+);
+fs.writeFileSync('report.csv', result);
+```
+
+**How it works:** The cloud browser fetches the URL, reads the response with
+`FileReader`, converts to Base64, and returns the data back to Node.js.
+
+For files triggered by button clicks (not direct URLs), the service uses CDP's
+`Fetch.enable` to intercept the download.
+
+
+## Session-Scoped File API
+
+All file operations are also available under `client.sessions.files`:
+
+```typescript
+await client.sessions.files.upload(session.id, buffer, 'file.txt');
+
+const files = await client.sessions.files.list(session.id);
+
+const data = await client.sessions.files.download(session.id, '/path/to/file');
+
+const archive = await client.sessions.files.downloadArchive(session.id);
+
+await client.sessions.files.delete(session.id, '/path/to/file');
+
+await client.sessions.files.deleteAll(session.id);
+```
+
+
+## File Info
+
+```typescript
+interface FileInfo {
+ path: string;
+ name: string;
+ size: number;
+ createdAt: string;
+ mimeType?: string;
+}
+```
+
+Files are stored locally in a `.files/` directory organized by session ID.
+
+
+
+
+
diff --git a/docs/browser-cloud-intro.md b/docs/browser-cloud-intro.md
new file mode 100644
index 000000000..fb3a0182f
--- /dev/null
+++ b/docs/browser-cloud-intro.md
@@ -0,0 +1,201 @@
+---
+id: browser-cloud-intro
+title: Welcome to TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: What is Browser Cloud?
+description: TestMu AI Browser Cloud is cloud browser infrastructure purpose-built for AI agents, with built-in stealth, session persistence, and full observability.
+keywords:
+ - browser cloud
+ - ai browser agents
+ - cloud browser infrastructure
+ - stealth browsing
+ - browser automation
+url: https://www.testmuai.com/support/docs/what-is-browser-cloud/
+site_name: TestMu AI
+slug: what-is-browser-cloud/
+canonical: https://www.testmuai.com/support/docs/what-is-browser-cloud/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Getting Started With TestMu AI Browser Cloud
+***
+
+TestMu AI is a scalable browser designed for AI agents to handle scraping, testing, and automation, without the overhead of managing infrastructure.
+
+
+Find all the guides, resources, and examples you need to build on Browser Cloud.
+
+
+
+## Get Started
+***
+
+
+
+## Features
+***
+
+
+
+## Cookbook
+***
+
+Ready-to-run examples to get you started fast.
+
+
+
+## Resources
+***
+
+
+
+
diff --git a/docs/browser-cloud-profiles.md b/docs/browser-cloud-profiles.md
new file mode 100644
index 000000000..81a009015
--- /dev/null
+++ b/docs/browser-cloud-profiles.md
@@ -0,0 +1,219 @@
+---
+id: browser-cloud-profiles
+title: Profiles - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Stay Logged in Across Runs
+description: Persist browser state across sessions and script runs. Reuse auth, cookies, and browser settings across sessions.
+keywords:
+ - browser cloud profiles
+ - persistent browser state
+ - session persistence
+ - cookie persistence
+ - browser identity
+url: https://www.testmuai.com/support/docs/browser-cloud-profiles/
+site_name: TestMu AI
+slug: browser-cloud-profiles/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-profiles/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Stay Logged In Across Runs with Profiles
+
+Persist and reuse browser state - cookies, auth, and settings - across separate script runs. Profiles auto-save when the browser closes and auto-load when you use the same profile ID.
+
+
+## Why You Need This
+
+The [Context service for cookies](/support/docs/browser-cloud-context/) transfers state between sessions
+within a single script run. But what if your agent runs on a cron schedule, or
+as a serverless function, or is manually triggered days apart? The in-memory
+context is lost between runs.
+
+Profiles solve this by saving your browser's state - cookies, localStorage,
+sessionStorage - to disk. Think of a profile as a saved browser identity: a set
+of credentials, preferences, and session data that your agent can load each
+time it runs. Your agent logs in once, the profile saves the auth state to
+disk, and every future run - hours, days, or weeks later - loads the saved
+state and skips login entirely.
+
+You might have a "salesforce-login" profile, a "github-login" profile, or a
+"competitor-research" profile - each maintaining its own authentication state
+and preferences.
+
+
+## How It Works
+
+1. You set `profileId` in your session config
+2. On connect, the adapter checks for a saved profile at `.profiles/{profileId}.json`
+3. If found, the saved cookies are loaded into the browser
+4. On `browser.close()`, the current cookies are automatically saved back to the file
+5. Next time you create a session with the same `profileId`, the saved state is restored
+
+
+## Getting Started
+
+```typescript
+// Run 1: Your agent logs in. Profile is saved automatically on close.
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ profileId: 'my-app-login', // This ID enables auto-save
+ lambdatestOptions: { ... }
+});
+
+const browser = await client.puppeteer.connect(session);
+const page = (await browser.pages())[0];
+
+await page.goto('https://app.example.com/login');
+// ... agent logs in ...
+
+await browser.close(); // ← Profile auto-saved here
+await client.sessions.release(session.id);
+```
+
+```typescript
+// Run 2 (days later): Agent loads saved state. No login needed.
+const session2 = await client.sessions.create({
+ adapter: 'puppeteer',
+ profileId: 'my-app-login', // Same ID = loads saved cookies
+ lambdatestOptions: { ... }
+});
+
+const browser2 = await client.puppeteer.connect(session2);
+const page2 = (await browser2.pages())[0];
+
+await page2.goto('https://app.example.com/dashboard');
+// Already logged in - cookies were restored from the profile
+```
+
+> **First run note:** On the very first run, there's no saved profile yet.
+> This is normal. The profile file is created when `browser.close()` is called.
+> Subsequent runs will find and load it.
+
+
+## Profile File Format
+
+Profiles are stored as JSON files at `.profiles/{profileId}.json`:
+
+```json
+{
+ "id": "my-app-login",
+ "cookies": [
+ {
+ "name": "session_token",
+ "value": "abc123...",
+ "domain": ".example.com",
+ "path": "/",
+ "expires": 1735689600,
+ "httpOnly": true,
+ "secure": true
+ }
+ ],
+ "updatedAt": "2024-01-15T10:30:00.000Z"
+}
+```
+
+
+## Manual Profile Management
+
+Beyond the automatic `profileId` flow, you can manage profiles directly:
+
+```typescript
+// Save a profile manually
+await client.profiles.saveProfile('my-profile', page, { note: 'after login' });
+
+// Load a profile into a page
+await client.profiles.loadProfile('my-profile', page);
+
+// List all saved profiles
+const profiles = await client.profiles.listProfiles();
+
+// Delete a profile
+await client.profiles.deleteProfile('my-profile');
+```
+
+
+## Profiles vs Context Service
+
+| | Context Service | Profile Service |
+|---|---|---|
+| **Where state lives** | In memory (JS object) | On disk (`.profiles/` directory) |
+| **Lifetime** | Single script run | Across runs (days/weeks) |
+| **Use case** | Transfer state between sessions in the same script | Maintain login state between separate agent invocations |
+| **How to use** | Manual `getContext()` / `setContext()` | Automatic via `profileId` in session config |
+
+**Use Context** when your agent creates multiple sessions in one run.
+**Use Profiles** when your agent runs on a schedule and needs to stay logged in
+between invocations.
+
+
+## Works With All CDP Adapters
+
+- **Puppeteer:** Saves/loads cookies via CDP page methods
+- **Playwright:** Saves/loads cookies via `context.addCookies()` / `context.cookies()`
+- **Selenium:** Saves/loads cookies via `driver.manage().addCookie()`, grouped by domain
+
+
+## Security Note
+
+Profile files contain session cookies and tokens in plain text. Add
+`.profiles/` to your `.gitignore`:
+
+```
+.profiles/
+```
+
+
+
diff --git a/docs/browser-cloud-quick-actions.md b/docs/browser-cloud-quick-actions.md
new file mode 100644
index 000000000..8da6edc3b
--- /dev/null
+++ b/docs/browser-cloud-quick-actions.md
@@ -0,0 +1,205 @@
+---
+id: browser-cloud-quick-actions
+title: Quick Actions - Scrape, Screenshot, PDF
+hide_title: true
+sidebar_label: One-Liner Scrape, Screenshot, and PDF
+description: One-liner operations that handle browser setup, navigation, and cleanup for scraping, screenshots, and PDF generation.
+keywords:
+ - browser cloud scrape
+ - browser cloud screenshot
+ - browser cloud pdf
+ - web scraping sdk
+ - quick actions
+url: https://www.testmuai.com/support/docs/browser-cloud-quick-actions/
+site_name: TestMu AI
+slug: browser-cloud-quick-actions/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-quick-actions/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# One-Liner Scrape, Screenshot, and PDF
+
+Scrape content, take screenshots, or generate PDFs from any URL - without managing sessions, browsers, or cleanup yourself. You provide
+a URL, you get back the result. The TestMu AI Browser SDK handles everything behind
+the scenes.
+
+This is useful when your agent needs data from a page but doesn't need to
+interact with it beyond extraction.
+
+
+## Scrape
+
+Extract content from any webpage in your choice of format.
+
+**Simplest form - just pass a URL:**
+
+```typescript
+const result = await client.scrape('https://example.com');
+console.log(result.content);
+```
+
+**With options - control format, timing, and selectors:**
+
+```typescript
+const result = await client.scrape({
+ url: 'https://example.com',
+ format: 'markdown', // 'html' | 'markdown' | 'text' | 'readability'
+ delay: 3000, // Wait 3 seconds for JS-heavy pages
+ waitFor: '#content', // Wait for this CSS selector before extracting
+});
+```
+
+**Response:**
+
+```typescript
+interface ScrapeResponse {
+ title: string; // Page title
+ content: string; // Extracted content in requested format
+ url: string; // Final URL (after redirects)
+ markdown?: string; // Markdown version
+ html?: string; // Raw HTML
+ metadata?: Record; // Meta tags
+}
+```
+
+**Choosing a format:**
+
+| Format | What You Get | When To Use It |
+|--------|-------------|----------------|
+| `html` | Raw HTML of the page | When your agent needs to parse the DOM |
+| `text` | Plain text, tags stripped | When you want minimal tokens for LLM input |
+| `readability` | Cleaned article content (like Reader Mode) | When the page has an article you want to extract |
+| `markdown` | HTML converted to markdown | When you want structure + low token count for LLMs |
+
+
+## Screenshot
+
+Capture a visual snapshot of any webpage.
+
+```typescript
+// Simple
+const result = await client.screenshot('https://example.com');
+fs.writeFileSync('screenshot.png', result.data);
+
+// With options
+const result = await client.screenshot({
+ url: 'https://example.com',
+ fullPage: true, // Capture entire scrollable page
+ format: 'jpeg', // 'png' | 'jpeg' | 'webp'
+ quality: 80, // JPEG/WebP quality (1-100)
+ delay: 2000, // Wait before capturing
+});
+```
+
+**Response:** `{ data: Buffer, format: string, width: number, height: number }`
+
+
+## PDF
+
+Generate a PDF document from any webpage.
+
+```typescript
+// Simple
+const result = await client.pdf('https://example.com');
+fs.writeFileSync('page.pdf', result.data);
+
+// With options
+const result = await client.pdf({
+ url: 'https://example.com',
+ format: 'A4', // 'A4' | 'Letter' | 'Legal'
+ landscape: false,
+ printBackground: true,
+ margin: { top: '1cm', right: '1cm', bottom: '1cm', left: '1cm' },
+});
+```
+
+**Response:** `{ data: Buffer, pageCount: number }`
+
+
+## Standalone vs Session Mode
+
+Quick Actions operate in two modes:
+
+**Standalone mode (default).** The SDK creates a temporary headless browser
+with stealth enabled, navigates to the URL, performs the operation, and closes
+the browser. Fully automatic. No session management needed.
+
+**Session mode.** If your agent already has a session running and you want the
+Quick Action to use that session's browser (with its cookies, tunnel, or
+extensions), register the page first:
+
+```typescript
+const session = await client.sessions.create({ ... });
+const browser = await client.puppeteer.connect(session);
+const page = (await browser.pages())[0];
+
+// Register the page for Quick Actions
+client.quick.registerSessionPage(session.id, page);
+
+// Now Quick Actions use the existing session
+const result = await client.scrape({
+ url: 'https://example.com',
+ sessionId: session.id,
+});
+```
+
+This is useful when the page requires authentication, a tunnel connection, or
+specific extensions to access.
+
+
+
+
+
diff --git a/docs/browser-cloud-quickstart.md b/docs/browser-cloud-quickstart.md
new file mode 100644
index 000000000..041bbcdfe
--- /dev/null
+++ b/docs/browser-cloud-quickstart.md
@@ -0,0 +1,260 @@
+---
+id: browser-cloud-quickstart
+title: Quickstart - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Launch Your First Session
+description: Get up and running with your first TestMu AI Browser Cloud session in a few minutes using TypeScript and Puppeteer.
+keywords:
+ - browser cloud quickstart
+ - browser cloud getting started
+ - testmu sdk setup
+ - puppeteer cloud browser
+ - ai agent browser setup
+url: https://www.testmuai.com/support/docs/launch-first-session/
+site_name: TestMu AI
+slug: launch-first-session/
+canonical: https://www.testmuai.com/support/docs/launch-first-session/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+
+# Launch Your First Browser Session
+***
+
+This guide walks you through setting up your account, creating
+your first browser session on 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://accounts.lambdatest.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);
+```
+
+
+
+
+:::note
+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,
+ }
+ }
+ });
+
+ console.log('Session created:', session.id);
+ console.log('View live session at:', session.sessionViewerUrl);
+
+ // Connect and use the browser
+ const driver = await client.selenium.connect(session);
+
+ await driver.get('https://example.com');
+ console.log('Title:', await driver.getTitle());
+
+ // Clean up
+ await driver.quit();
+ await client.sessions.release(session.id);
+ console.log('Session released');
+}
+
+main().catch(console.error);
+```
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/browser-cloud-session-configuration.md b/docs/browser-cloud-session-configuration.md
new file mode 100644
index 000000000..2bcddf2a1
--- /dev/null
+++ b/docs/browser-cloud-session-configuration.md
@@ -0,0 +1,184 @@
+---
+id: browser-cloud-session-configuration
+title: Session Configuration - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Configure Session Options
+description: Complete reference for all options available when creating a session with the TestMu AI Browser SDK.
+keywords:
+ - browser cloud configuration
+ - session options
+ - stealth config
+ - browser cloud settings
+ - session create options
+url: https://www.testmuai.com/support/docs/browser-cloud-session-configuration/
+site_name: TestMu AI
+slug: browser-cloud-session-configuration/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-session-configuration/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Configure Session Options
+
+Complete reference for all options available when creating a session with the TestMu AI Browser SDK. Use these to control stealth, persistence, browser settings, network, and extensions.
+
+When you call `client.sessions.create()`, you can pass these options to
+configure the session's behavior, browser settings, and capabilities.
+
+## Quick Example
+
+Here is a typical `create` call that sets the most common options:
+
+```javascript
+const session = await client.sessions.create({
+ adapter: 'playwright',
+ dimensions: { width: 1920, height: 1080 },
+ blockAds: true,
+ stealthConfig: {
+ humanizeInteractions: true,
+ randomizeUserAgent: true,
+ },
+ proxy: 'http://my-proxy:8080',
+ lambdatestOptions: {
+ build: 'my-build',
+ name: 'my-test',
+ user: process.env.LT_USERNAME,
+ accessKey: process.env.LT_ACCESS_KEY,
+ },
+});
+```
+
+The sections below describe every available option in detail.
+
+## Required Options
+
+| Option | Type | Description |
+|--------|------|----------------|
+| `adapter` | `'puppeteer' \| 'playwright' \| 'selenium'` | Which automation library to use |
+| `lambdatestOptions` | `object` | capabilities (build name, test name, credentials) |
+
+## Stealth Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|----------------|
+| `stealthConfig.humanizeInteractions` | `boolean` | `false` | Add random delays to clicks and typing |
+| `stealthConfig.randomizeUserAgent` | `boolean` | `true` | Pick random user-agent from pool |
+| `stealthConfig.randomizeViewport` | `boolean` | `true` | Add ±20px jitter to viewport |
+| `stealthConfig.skipFingerprintInjection` | `boolean` | `false` | Disable all stealth |
+
+→ Learn more: [Avoid bot detection with Stealth Mode](/support/docs/browser-cloud-stealth/)
+
+## Persistence Options
+
+| Option | Type | Description |
+|--------|------|----------------|
+| `profileId` | `string` | Load/save persistent browser profile |
+| `sessionContext` | `SessionContext` | Pre-load cookies, localStorage, sessionStorage |
+
+
+## Browser Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|----------------|
+| `dimensions` | `{ width, height }` | - | Browser viewport size |
+| `userAgent` | `string` | - | Custom user-agent string |
+| `headless` | `boolean` | - | Run in headless mode |
+| `timeout` | `number` | `300000` | Session timeout in ms (5 min) |
+| `blockAds` | `boolean` | - | Block advertisements |
+| `solveCaptcha` | `boolean` | - | Enable CAPTCHA solving |
+
+## Network Options
+
+| Option | Type | Description |
+|--------|------|----------------|
+| `proxy` | `string` | Proxy URL |
+| `geoLocation` | `string` | Geolocation code (e.g. `'US'`, `'IN'`) |
+| `tunnel` | `boolean` | Enable tunnel |
+| `tunnelName` | `string` | Named tunnel identifier |
+| `region` | `string` | data center region |
+| `optimizeBandwidth` | `boolean \| config` | Block images/media/styles |
+
+
+## Extension Options
+
+| Option | Type | Description |
+|--------|------|----------------|
+| `extensionIds` | `string[]` | Chrome extension IDs to load |
+
+
+
+## Session Object
+
+After creation, you receive a Session object with these fields:
+
+```typescript
+interface Session {
+ id: string; // Unique session ID
+ websocketUrl: string; // WebSocket URL for adapter connection
+ debugUrl: string; // TestMu AI dashboard URL
+ config: SessionConfig; // Original configuration
+ status: 'live' | 'released' | 'failed';
+ createdAt: string; // ISO timestamp
+ timeout: number; // Session timeout in ms
+ dimensions: Dimensions; // Viewport dimensions
+ sessionViewerUrl?: string; // Live session viewer URL
+ userAgent?: string; // Resolved user-agent
+ stealthConfig?: StealthConfig; // Active stealth settings
+}
+```
+
+
+
+
diff --git a/docs/browser-cloud-session-lifecycle.md b/docs/browser-cloud-session-lifecycle.md
new file mode 100644
index 000000000..93ac435ad
--- /dev/null
+++ b/docs/browser-cloud-session-lifecycle.md
@@ -0,0 +1,195 @@
+---
+id: browser-cloud-session-lifecycle
+title: Session Lifecycle - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Handle Session Lifecycle
+description: How sessions are created, managed, and released in TestMu AI Browser Cloud.
+keywords:
+ - browser cloud session lifecycle
+ - session states
+ - session timeout
+ - release session
+ - browser session management
+url: https://www.testmuai.com/support/docs/browser-cloud-session-lifecycle/
+site_name: TestMu AI
+slug: browser-cloud-session-lifecycle/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-session-lifecycle/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Handle Session Lifecycle
+
+Learn how sessions move from creation to release, and how to manage timeouts and cleanup.
+Understanding the session lifecycle helps you avoid leaked sessions, reduce wasted resources, and ensure clean recordings on your dashboard.
+
+
+## Session States
+
+Every session passes through a simple set of states during its lifetime:
+
+```
+create() ──→ live ──→ released
+ └──→ failed
+```
+
+**Live.** The session has been created and is ready for connections. Your agent
+can connect, navigate, and interact with the browser. The session stays in this
+state until you release it or it times out.
+
+**Released.** The session has been explicitly released by your code, or it
+reached its timeout. The browser is closed, resources are freed, and the
+recording is saved to the dashboard.
+
+**Failed.** Something went wrong - a crash, connection loss, or infrastructure
+error. Failed sessions are automatically cleaned up.
+
+
+## Session Timeout
+
+Every session has a timeout that defines how long it stays alive. The default is
+**5 minutes** (300,000 ms). After this time, the session is automatically
+released whether your agent is still using it or not.
+
+You can adjust the timeout when creating a session:
+
+```typescript
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ timeout: 600000, // 10 minutes
+ lambdatestOptions: { ... }
+});
+```
+
+For quick scrapes, the default 5 minutes is usually enough. For multi-step
+workflows where your agent navigates through several pages, you may want
+10–30 minutes.
+
+
+## Releasing Sessions
+
+When your agent is done, release the session explicitly. This frees resources
+immediately and ensures a clean recording on the dashboard:
+
+```typescript
+// Release a single session
+await client.sessions.release(session.id);
+```
+
+If your agent manages multiple sessions in parallel, you can release all of
+them at once:
+
+```typescript
+// Release all active sessions
+await client.sessions.releaseAll();
+```
+
+
+## Listing and Retrieving Sessions
+
+You can check which sessions are currently active and retrieve details about any
+specific session:
+
+```typescript
+// List all active sessions
+const sessions = client.sessions.list();
+
+// Get details of a specific session
+const session = client.sessions.retrieve('session_12345_abc');
+```
+
+
+## Live Session Details
+
+While a session is running, you can get real-time information about it:
+
+```typescript
+const details = await client.sessions.liveDetails(session.id);
+
+console.log(details.pages); // Currently open pages/tabs
+console.log(details.wsUrl); // WebSocket URL
+console.log(details.sessionViewerUrl); // Live viewer URL
+```
+
+
+## Best Practices
+
+**Always release sessions when done.** Don't rely on timeouts alone - they
+exist as a safety net, not as your primary cleanup mechanism:
+
+```typescript
+const session = await client.sessions.create({ ... });
+try {
+ const browser = await client.puppeteer.connect(session);
+ // ... your agent's work ...
+ await browser.close();
+} finally {
+ await client.sessions.release(session.id);
+}
+```
+
+**Use `releaseAll()` in your shutdown handler.** If your agent process crashes,
+you want to make sure no sessions are left running:
+
+```typescript
+process.on('SIGINT', async () => {
+ await client.sessions.releaseAll();
+ process.exit(0);
+});
+```
+
+
+
+
diff --git a/docs/browser-cloud-sessions-overview.md b/docs/browser-cloud-sessions-overview.md
new file mode 100644
index 000000000..4a9ce4dca
--- /dev/null
+++ b/docs/browser-cloud-sessions-overview.md
@@ -0,0 +1,128 @@
+---
+id: browser-cloud-sessions-overview
+title: Sessions Overview - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Understand the Sessions API
+description: The Sessions API lets you create and control cloud-based browser sessions through simple SDK calls in TestMu AI Browser Cloud.
+keywords:
+ - browser cloud sessions
+ - browser sessions api
+ - cloud browser instance
+ - ai agent browser session
+ - websocket browser automation
+url: https://www.testmuai.com/support/docs/browser-cloud-sessions-overview/
+site_name: TestMu AI
+slug: browser-cloud-sessions-overview/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-sessions-overview/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Understanding the Sessions API
+
+The Sessions API lets you create and control cloud-based browser sessions
+through simple SDK calls. Each session is like giving your AI agent its own
+dedicated browser window, but running on Browser Cloud and controlled
+through your code.
+
+
+## Sessions at a Glance
+
+When you create a session, you get a fully isolated Chrome browser running in
+ Browser Cloud that your code controls. Each browser has its own
+state, cookies, and storage, so your AI agent can navigate the web, interact
+with sites, and maintain context across multiple steps without interference
+from other sessions.
+
+Specifically, each session gives you:
+
+1. A **session ID** to track and manage it
+2. A **WebSocket URL** to connect your automation tool (Puppeteer, Playwright, or Selenium)
+3. A **debug URL** to watch the session on the dashboard
+4. A **session viewer URL** for real-time streaming of the browser
+
+
+## Before You Begin
+
+If you have not set up your account and installed the SDK yet, [launch your first session](/support/docs/launch-first-session/) before working with sessions.
+
+
+## How It Works
+
+```
+Your Agent TestMu AI Cloud
+ │ │
+ ├── client.sessions.create() ────────→ │ Spins up a real Chrome browser
+ │ │ Returns session ID + WebSocket URL
+ │ │
+ ├── client.puppeteer.connect() ──────→ │ Your agent drives the browser
+ │ page.goto(...) │ via WebSocket (CDP)
+ │ page.click(...) │
+ │ page.type(...) │
+ │ │
+ ├── browser.close() ─────────────────→ │ Browser disconnects
+ │ │
+ └── client.sessions.release() ───────→ │ Session cleaned up
+ │ Resources freed
+```
+
+Your agent creates a session, connects to it using its preferred automation
+library, does its work, and releases the session when done. That's the entire
+lifecycle.
+
+
+
+
+
diff --git a/docs/browser-cloud-skills.md b/docs/browser-cloud-skills.md
new file mode 100644
index 000000000..71afe0226
--- /dev/null
+++ b/docs/browser-cloud-skills.md
@@ -0,0 +1,301 @@
+---
+id: browser-cloud-skills
+title: AI Agent Skills - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: AI Agent Skills
+description: 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.
+keywords:
+ - browser cloud skills
+ - ai agent tools
+ - langchain browser tool
+ - crewai browser tool
+ - openai function calling browser
+ - agent framework integration
+ - claude browser skill
+ - cursor browser skill
+url: https://www.testmuai.com/support/docs/browser-cloud-skills/
+site_name: TestMu AI
+slug: browser-cloud-skills/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-skills/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+
+# AI Agent Skills
+
+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 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)
+- ** 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
+```
+
+:::note
+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
+
+Build a LangChain agent that can browse the web as one of its tools:
+
+```typescript
+import { buildBrowserAgent } from './browser-cloud/examples/langchain-browser-tool';
+
+const agent = await buildBrowserAgent();
+const result = await agent.invoke({
+ input: 'Research the latest pricing for our top three competitors.',
+});
+```
+
+### Parallel Research Across URLs
+
+Run multiple isolated browser sessions concurrently with progress tracking:
+
+```typescript
+import { parallelResearch } from './browser-cloud/examples/parallel-research';
+
+const results = await parallelResearch([
+ 'https://competitor-a.com/pricing',
+ 'https://competitor-b.com/pricing',
+ 'https://competitor-c.com/pricing',
+], 3);
+```
+
+---
+
+## Supported Frameworks
+
+| Framework | Language | Status | Reference |
+|-----------|----------|--------|-----------|
+| **LangChain** | TypeScript | Ready | `browser-cloud/examples/langchain-browser-tool.ts` |
+| **OpenAI function calling** | TypeScript | Ready | `browser-cloud/references/integrations/openai-functions.md` |
+| **Anthropic tool use** | TypeScript | Ready | `browser-cloud/references/integrations/openai-functions.md` |
+| **CrewAI** | Python | Ready (subprocess bridge) | `browser-cloud/references/integrations/crewai.md` |
+| **AutoGen** | Python | Use OpenAI pattern | `browser-cloud/references/integrations/openai-functions.md` |
+| **Custom agent loop** | Any | Drop-in function | Any file in `browser-cloud/examples/` |
+
+---
+
+## Supported Capabilities
+
+| Capability | What It Does |
+|------------|-------------|
+| **Stealth mode** | 15+ fingerprint patches (Puppeteer) / 6 init scripts (Playwright). Humanized click/type timing. Randomized UA and viewport. |
+| **Auth persistence** | Save login state to disk. Reload on every run. Zero re-logins for scheduled agents. |
+| **Context transfer** | Pass cookies and storage between sessions in the same script run. |
+| **Tunnel** | Access localhost, staging, or VPN-gated URLs from cloud browsers. |
+| **Parallel sessions** | Multiple isolated browsers running concurrently with batching support. |
+| **File transfer** | Upload local files to cloud browser. Download exports, receipts, reports back to disk. |
+| **Extensions** | Load Chrome extensions into sessions from S3 URLs. |
+| **Quick Actions** | One-liner scrape, screenshot, and PDF. No session management required. |
+| **Observability** | Every session gets video recording, console logs, and network capture in your automation session history. |
+
+---
+
+## Skill Repo Structure
+
+```
+├── package.json ← npm scripts and SDK dependency
+├── README.md
+│
+└── browser-cloud/ ← Skill bundle
+ ├── SKILL.md ← Load this into your AI tool
+ ├── examples/
+ │ ├── scrape-agent.ts ← Batch scraping with concurrency control
+ │ ├── form-fill-agent.ts ← Form interaction with Playwright + stealth
+ │ ├── auth-persist-agent.ts ← Login once, reuse session across runs
+ │ ├── parallel-research.ts ← Parallel sessions with progress tracking
+ │ └── langchain-browser-tool.ts ← Four LangChain tool variants
+ └── references/
+ ├── patterns/
+ │ ├── quick-actions.md ← Scrape / screenshot / PDF one-liners
+ │ ├── session-navigate.md ← Multi-step navigation and interaction
+ │ ├── auth-profile.md ← Auth persistence patterns
+ │ ├── parallel-sessions.md ← Concurrent agent sessions
+ │ ├── tunnel.md ← Localhost and internal network access
+ │ └── files.md ← Upload/download between agent and browser
+ └── integrations/
+ ├── openai-functions.md ← OpenAI + Anthropic function calling
+ └── crewai.md ← CrewAI BaseTool (Python + Node bridge)
+```
+
+---
+
+## Contributing
+
+Contributions welcome at the [browser-cloud-skills repo](https://github.com/LambdaTest/browser-cloud-skills). The most useful additions are:
+
+- New **pattern files** in `browser-cloud/references/patterns/` for use cases not currently covered
+- New **integration files** in `browser-cloud/references/integrations/` for frameworks not yet supported
+- New **runnable examples** in `browser-cloud/examples/`
+- Improvements to `browser-cloud/SKILL.md` that make the LLM output more correct or more concise
+
+:::tip
+Keep `SKILL.md` under 500 lines. Every addition should remove or replace something weaker. The skill is a decision engine, not a tutorial.
+:::
+
+
diff --git a/docs/browser-cloud-stealth.md b/docs/browser-cloud-stealth.md
new file mode 100644
index 000000000..89707e603
--- /dev/null
+++ b/docs/browser-cloud-stealth.md
@@ -0,0 +1,251 @@
+---
+id: browser-cloud-stealth
+title: Stealth Mode - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Stealth Mode to Avoid Bot Detection
+description: Make your agent's browser look like a real human user to bot-detection systems with TestMu AI Browser Cloud stealth mode.
+keywords:
+ - browser cloud stealth
+ - bot detection evasion
+ - fingerprint masking
+ - humanize interactions
+ - anti-detection browser
+url: https://www.testmuai.com/support/docs/browser-cloud-stealth/
+site_name: TestMu AI
+slug: browser-cloud-stealth/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-stealth/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Avoid Bot Detection with Stealth Mode
+
+Make your agent's browser look like a real human user to bot-detection systems. Stealth mode masks fingerprints, randomizes user-agents, and humanizes interactions automatically.
+
+
+## Why Stealth Matters
+
+If your automated browser is getting blocked, served CAPTCHAs, or shown
+different content than a real user would see, it is likely because the target
+site's bot detection is flagging your session. Automated browsers leave
+detectable fingerprints that these systems check for:
+
+- `navigator.webdriver` is set to `true`
+- Missing Chrome plugins and runtime objects
+- Exact, round viewport dimensions like `1920x1080`
+- Identical user-agent strings across all sessions
+- Inhuman interaction speeds - instant clicks, perfectly uniform typing
+
+Stealth mode in the TestMu AI Browser SDK removes or fakes these fingerprints, so
+the cloud browser is indistinguishable from a regular human user's Chrome
+session.
+
+
+## Enabling Stealth
+
+Add a `stealthConfig` to your session. That's it - the adapter handles
+everything else automatically:
+
+```typescript
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ stealthConfig: {
+ humanizeInteractions: true,
+ randomizeUserAgent: true,
+ randomizeViewport: true,
+ },
+ lambdatestOptions: { ... }
+});
+```
+
+
+## Configuration Reference
+
+| Option | Type | Default | What It Does |
+|--------|------|---------|----------------|
+| `humanizeInteractions` | `boolean` | `false` | Adds random delays to clicks (50–150ms) and typing (30–130ms per character) |
+| `randomizeUserAgent` | `boolean` | `true` | Picks a random user-agent from a pool of 7 realistic Chrome/Firefox strings |
+| `randomizeViewport` | `boolean` | `true` | Adds ±20px random jitter to viewport dimensions |
+| `skipFingerprintInjection` | `boolean` | `false` | Disables all stealth entirely (Puppeteer only, useful for comparison testing) |
+
+
+## What Gets Patched
+
+The specific evasions depend on which adapter you're using.
+
+**Puppeteer** uses `puppeteer-extra` with the stealth plugin. This is the most
+comprehensive stealth solution available, patching:
+
+- `navigator.webdriver` (set to `undefined`)
+- Chrome runtime objects
+- WebGL vendor/renderer
+- Permission queries
+- Language and platform strings
+- iframe contentWindow access
+- Console.debug behavior
+- And approximately 15 more evasions
+
+**Playwright** uses custom scripts injected via `page.addInitScript()`. These
+scripts run **before** any page JavaScript executes, so detection scripts
+cannot observe the original values:
+
+| Evasion | What It Does |
+|---------|----------------|
+| `navigator.webdriver = false` | Hides the automation flag |
+| Fake `chrome.runtime` | Makes it look like Chrome extensions are present |
+| Fake `navigator.plugins` | Injects 3 standard Chrome plugins (PDF Plugin, PDF Viewer, Native Client) |
+| `navigator.languages` | Set to `['en-US', 'en']` |
+| `permissions.query` | Returns `'denied'` for notifications (matches real Chrome) |
+| WebGL spoofing | Reports "Intel Inc." / "Intel Iris OpenGL Engine" as GPU |
+
+> **Selenium** does not support stealth mode. Use Puppeteer or Playwright if
+> your agent needs anti-detection.
+
+
+## User-Agent Randomization
+
+When `randomizeUserAgent` is enabled (it is by default when any `stealthConfig`
+is set), the SDK picks from a pool of 7 realistic user-agent strings covering
+Chrome 119–120 and Firefox 121 on Windows, macOS, and Linux.
+
+The user-agent is selected **once** at session creation and stays consistent for
+the entire session. This is important - changing user-agent mid-session is a
+detection signal.
+
+If you provide an explicit `userAgent` in the session config, it takes priority
+over randomization.
+
+
+## Viewport Randomization
+
+When `randomizeViewport` is enabled, the SDK adds ±20 pixels of random jitter
+to your base viewport dimensions. Instead of the perfectly round `1920x1080`
+that bots typically fingerprint as, your session might run at `1907x1063` -
+subtly different each time.
+
+
+## Humanized Interactions
+
+When `humanizeInteractions` is enabled, the SDK monkey-patches interaction
+methods to add random delays:
+
+| Method | Adapter | Delay |
+|--------|---------|--------|
+| `page.click(selector)` | Puppeteer, Playwright | Random 50–150ms before clicking |
+| `page.type(selector, text)` | Puppeteer, Playwright | Random 30–130ms between each character |
+| `page.fill(selector, value)` | Playwright only | Random 50–150ms before filling |
+
+New pages created during the session automatically inherit the same humanized
+behavior.
+
+
+## Disabling Stealth
+
+To explicitly disable stealth (useful for comparison testing or sites that
+don't use bot detection):
+
+```typescript
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ stealthConfig: {
+ skipFingerprintInjection: true,
+ randomizeUserAgent: false,
+ randomizeViewport: false,
+ },
+ lambdatestOptions: { ... }
+});
+```
+
+
+## Testing Your Stealth Setup
+
+The TestMu AI Browser SDK includes a built-in test that visits the bot detection
+site `bot.sannysoft.com` with stealth ON and OFF, saving screenshots for visual
+comparison:
+
+Screenshots are saved to `test-output/`. Stealth ON shows green checks; stealth
+OFF shows red failures.
+
+
+## How Stealth Works
+
+```
+Session Creation
+ │
+ ├─ stealthConfig present?
+ │ ├─ Yes → pick random UA, store on session.userAgent
+ │ └─ No → skip
+ │
+ ▼
+Adapter.connect()
+ │
+ ├─ Puppeteer:
+ │ ├─ skipFingerprintInjection? → raw puppeteer.connect()
+ │ └─ else → puppeteerExtra.connect() with stealth plugin
+ │ ├─ Set random UA via page.setUserAgent()
+ │ ├─ Set random viewport via page.setViewport()
+ │ └─ Humanize: monkey-patch click/type
+ │
+ └─ Playwright:
+ ├─ Inject stealth scripts via page.addInitScript()
+ ├─ Auto-apply to new pages via context.on('page')
+ ├─ Set random UA via page.evaluate()
+ ├─ Set random viewport via page.setViewportSize()
+ └─ Humanize: monkey-patch click/type/fill
+```
+
+
+
+
diff --git a/docs/browser-cloud-tunnel.md b/docs/browser-cloud-tunnel.md
new file mode 100644
index 000000000..68f18a855
--- /dev/null
+++ b/docs/browser-cloud-tunnel.md
@@ -0,0 +1,183 @@
+---
+id: browser-cloud-tunnel
+title: Tunnel - TestMu AI Browser Cloud
+hide_title: true
+sidebar_label: Access Localhost and Internal Networks
+description: Access localhost and internal networks from cloud browsers in TestMu AI Browser Cloud.
+keywords:
+ - browser cloud tunnel
+ - localhost cloud browser
+ - encrypted tunnel
+ - internal network access
+ - vpn cloud browser
+url: https://www.testmuai.com/support/docs/browser-cloud-tunnel/
+site_name: TestMu AI
+slug: browser-cloud-tunnel/
+canonical: https://www.testmuai.com/support/docs/browser-cloud-tunnel/
+---
+
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+# Access Localhost and Internal Networks Using Tunnel
+
+Create encrypted tunnels between your local machine and Browser Cloud. Let cloud browsers reach localhost dev servers, staging environments, and private network resources.
+
+
+## Why You Need This
+
+Your cloud browser can only reach public URLs by default. But your agent may need to access localhost, staging servers, or internal tools. For example:
+
+- Test a local development server before deploying
+- Access a staging environment behind a corporate VPN
+- Interact with internal tools and dashboards
+- Work with a local API backend
+
+The Tunnel Service solves this by creating an encrypted connection between your local machine and 's cloud infrastructure. Once the tunnel is running, your Browser Cloud sessions can reach any URL that your machine can reach - including `localhost`, private IPs, and internal hostnames.
+
+```
+Cloud Browser --(encrypted tunnel)--> Your Machine --> localhost:3000
+ --> staging.internal.company.com
+ --> 192.168.1.50:8080
+```
+
+
+## Automatic Tunnel (Recommended)
+
+The easiest approach. Set `tunnel: true` in your session config and the
+TestMu AI Browser SDK handles starting and routing the tunnel automatically:
+
+```typescript
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ tunnel: true,
+ tunnelName: 'my-tunnel', // Optional: name for identification
+ lambdatestOptions: { ... }
+});
+
+const browser = await client.puppeteer.connect(session);
+const page = (await browser.pages())[0];
+
+await page.goto('http://localhost:3000'); // This works!
+```
+
+If you set `tunnel: true` without a `tunnelName`, the SDK auto-generates a name
+and starts the tunnel for you.
+
+
+## Manual Tunnel
+
+For more control - for example, starting the tunnel once and reusing it across
+multiple sessions:
+
+```typescript
+// Start the tunnel
+await client.tunnel.start({
+ user: process.env.LT_USERNAME!,
+ key: process.env.LT_ACCESS_KEY!,
+ tunnelName: 'my-tunnel',
+});
+
+console.log('Tunnel running:', client.tunnel.getStatus()); // true
+
+// Create sessions that use it
+const session = await client.sessions.create({
+ adapter: 'puppeteer',
+ tunnel: true,
+ tunnelName: 'my-tunnel',
+ lambdatestOptions: { ... }
+});
+
+// ... agent work ...
+
+// Stop when done
+await client.tunnel.stop();
+```
+
+
+## Tunnel Config
+
+```typescript
+interface TunnelConfig {
+ user: string; // TestMu AI username
+ key: string; // TestMu AI access key
+ tunnelName?: string; // Named tunnel for identification
+ proxyHost?: string; // Corporate proxy host
+ proxyPort?: string; // Corporate proxy port
+ proxyUser?: string; // Proxy auth user
+ proxyPass?: string; // Proxy auth password
+ logFile?: string; // Log file path
+}
+```
+
+
+## API
+
+```typescript
+await client.tunnel.start(config); // Start tunnel
+await client.tunnel.stop(); // Stop tunnel
+client.tunnel.getStatus(); // Returns true/false
+```
+
+
+## How It Works
+
+The Tunnel Service uses the `@lambdatest/node-tunnel` package to create a
+binary tunnel connection to infrastructure. The tunnel name is passed
+as a capability so cloud browsers know to route their traffic through
+your local machine.
+
+
+
+
diff --git a/docs/browser-testing-with-real-devices.md b/docs/browser-testing-with-real-devices.md
index 2560222e0..de3afac85 100644
--- a/docs/browser-testing-with-real-devices.md
+++ b/docs/browser-testing-with-real-devices.md
@@ -1,95 +1,98 @@
----
-id: browser-testing-on-real-devices
-title: Getting started with Real Device Browser Testing
-hide_title: true
-sidebar_label: Getting Started
-description: With LambdaTest, conduct live interactive testing of websites and web apps on real Android and iOS devices to ensure a seamless user experience.
-keywords:
-- real device browser testing
-- lambdatest real device browser testing
-url: https://www.lambdatest.com/support/docs/browser-testing-on-real-devices/
-site_name: LambdaTest
-slug: browser-testing-on-real-devices/
----
-
-
-
-# Getting Started with Real Device Browser Testing
-***
-
-Real device browser testing refers to the process of testing web applications and websites on real devices such as smartphones, tablets, and computers to ensure that the user interface and user experience are optimal across various device types, operating systems, and browser combinations. With LambdaTest’s real device cloud, you can test websites and web applications to ensure they perform seamlessly across 10000 + real mobile devices.
-
-
-
-***
-
-**Step 1:** Login to your LambdaTest account. From the left sidebar, head to Real Device and select **Browser Testing**.
-
-**Step 2**: Select the **OS** and **browser** of your choice.
-
->**Note:** Certain browsers might not be supported on certain devices.
-
-**Step 3**: Select the **real device** of your choice. You can also search the preferred real **Android** or **iOS** device in the search bar.
-
-**Step 4**: In the case of **Android** devices, simply enter the website URL in the address bar.
-
-In the case of **iOS** devices, you can enter the website URL once the session has started.
-
-**Step 5**: Select the **Tunnel** option in the top right corner to test your locally hosted and privately hosted websites.
-
-Check out our detailed [support documentation](https://www.lambdatest.com/support/docs/testing-locally-hosted-pages/) to learn how to activate the LT Tunnel.
-
-**Step 6**: Click on Start to run your test session.
-
-
-
-
\ No newline at end of file
+---
+id: browser-testing-on-real-devices
+title: Getting started with Real Device Browser Testing
+hide_title: true
+sidebar_label: Getting Started
+description: With TestMu AI, conduct live interactive testing of websites and web apps on real Android and iOS devices to ensure a seamless user experience.
+keywords:
+- real device browser testing
+- testmu ai real device browser testing
+url: https://www.testmuai.com/support/docs/browser-testing-on-real-devices/
+site_name: TestMu AI
+slug: browser-testing-on-real-devices/
+canonical: https://www.testmuai.com/support/docs/browser-testing-on-real-devices/
+---
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
+
+
+
+# Getting Started with Real Device Browser Testing
+***
+
+Real device browser testing refers to the process of testing web applications and websites on real devices such as smartphones, tablets, and computers to ensure that the user interface and user experience are optimal across various device types, operating systems, and browser combinations. With ’s real device cloud, you can test websites and web applications to ensure they perform seamlessly across 3000 + real mobile devices.
+
+
+
+***
+
+**Step 1:** Login to your account. From the left sidebar, head to Real Device and select **Browser Testing**.
+
+**Step 2**: Select the **OS** and **browser** of your choice.
+
+>**Note:** Certain browsers might not be supported on certain devices.
+
+**Step 3**: Select the **real device** of your choice. You can also search the preferred real **Android** or **iOS** device in the search bar.
+
+**Step 4**: In the case of **Android** devices, simply enter the website URL in the address bar.
+
+In the case of **iOS** devices, you can enter the website URL once the session has started.
+
+**Step 5**: Select the **Tunnel** option in the top right corner to test your locally hosted and privately hosted websites.
+
+Check out our detailed [support documentation](/support/docs/testing-locally-hosted-pages/) to learn how to activate the LT Tunnel.
+
+**Step 6**: Click on Start to run your test session.
+
+
+
+
diff --git a/docs/browserstack-to-lambdatest-migration-guide.md b/docs/browserstack-to-lambdatest-migration-guide.md
index 8e5399c13..5c648c195 100644
--- a/docs/browserstack-to-lambdatest-migration-guide.md
+++ b/docs/browserstack-to-lambdatest-migration-guide.md
@@ -1,18 +1,19 @@
---
id: browserstack-to-lambdatest-migration-guide
-title: How to migrate from BrowserStack to LambdaTest
+title: How to migrate from BrowserStack to TestMu AI
hide_title: true
-sidebar_label: BrowserStack To LambdaTest Migration
-description: Using this guide, you can seamlessly migrate from BrowserStack to LambdaTest. It showcases a hands-on implementation using which you can run tests on LambdaTest (within few minutes)
+sidebar_label: BrowserStack To TestMu AI Migration
+description: Using this guide, you can seamlessly migrate from BrowserStack to TestMu AI. It showcases a hands-on implementation using which you can run tests on TestMu AI (within few minutes)
keywords:
- - browserstack lambdatest migration
- - browserstack lambdatest porting
- - browserstack lambdatest selenium testing
- - browserstack lambdatest migration guide
- - how to migrate from browserstack to lambdatest
-url: https://www.lambdatest.com/support/docs/browserstack-to-lambdatest-migration-guide/
-site_name: LambdaTest
-slug: browserstack-to-lambdatest-migration-guide/
+ - browserstack testmu ai migration
+ - browserstack testmu ai porting
+ - browserstack testmu ai selenium testing
+ - browserstack testmu ai migration guide
+ - how to migrate from browserstack to testmu ai
+url: https://www.testmuai.com/support/docs/browserstack-to-testmu-migration-guide/
+site_name: TestMu AI
+slug: browserstack-to-testmu-migration-guide/
+canonical: https://www.testmuai.com/support/docs/browserstack-to-testmu-migration-guide/
---
@@ -21,6 +22,9 @@ import {YOUR_LAMBDATEST_USERNAME, YOUR_LAMBDATEST_ACCESS_KEY} from "@site/src/co
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+import { CookieTrackingSignup } from '@site/src/component/CookieTracking';
+
migration",
+ "item": `${BRAND_URL}/support/docs/browserstack-to-testmu-migration-guide/`
}]
})
}}
>
-# Migration from BrowserStack to LambdaTest
+# Migration from BrowserStack to
* * *
-LambdaTest and BrowserStack both offer the cloud-based Selenium Grid. Hence, you can easily migrate your existing Selenium test automation scripts (or suites) from BrowserStack to LambdaTest
+ and BrowserStack both offer the cloud-based Selenium Grid. Hence, you can easily migrate your existing Selenium test automation scripts (or suites) from BrowserStack to
[Note: This guide covers the migration of tests running on the cloud grid that uses Selenium 4 and Selenium 3]
## Authentication
-Firstly, you need to change the authentication in your configuration settings of your test suite. For running tests on LambdaTest Selenium Grid, you need to have a valid user_name and access_key to perform tests on our Grid. In case you do not have an account on LambdaTest, visit the [LambdaTest signup page](https://accounts.lambdatest.com/register) and create a new account.
+Firstly, you need to change the authentication in your configuration settings of your test suite. For running tests on Selenium Grid, you need to have a valid user_name and access_key to perform tests on our Grid. In case you do not have an account on , visit the signup page and create a new account.
-When migrating your Selenium 4 tests from BrowserStack to LambdaTest, the following updates are required in your existing code:
+When migrating your Selenium 4 tests from BrowserStack to , the following updates are required in your existing code:
-1. Get LambdaTest Credentials: You can find these credentials under Account Settings > [Password & Security](https://accounts.lambdatest.com/security/username-accesskey) and copy your Username and Access Key, then add them to the .env file to keep them safe from public exposure.
+1. Get Credentials: You can find these credentials under Account Settings > [Password & Security](https://accounts.lambdatest.com/security/username-accesskey) and copy your Username and Access Key, then add them to the .env file to keep them safe from public exposure.
-2. Create .env file: Securely store your LambdaTest credentials, create a .env file in the root of your project and add the following values:
+2. Create .env file: Securely store your credentials, create a .env file in the root of your project and add the following values:
```
LT_USERNAME=""
LT_ACCESS_KEY=""
```
-Once the .env file is set up, ensure your test framework correctly reads these variables at runtime. This helps keep your authentication secure and avoids hard-coding credentials within your scripts. With the credentials in place, you’re now ready to update your Hub URL for LambdaTest execution.
+Once the .env file is set up, ensure your test framework correctly reads these variables at runtime. This helps keep your authentication secure and avoids hard-coding credentials within your scripts. With the credentials in place, you’re now ready to update your Hub URL for execution.
## Changes in Hub URL
@@ -92,7 +96,7 @@ You need to now change the hub URL in the configuration settings of your test su
-
+
```js
@hub.lambdatest.com/wd/hub
@@ -102,13 +106,13 @@ You need to now change the hub URL in the configuration settings of your test su
-## Configuring Selenium 4 Tests on LambdaTest
+## Configuring Selenium 4 Tests on
***
-Migrating your Selenium 4 tests from BrowserStack to LambdaTest requires only a few small updates. In this guide, we’ll walk through how to apply LambdaTest’s W3C-compliant capabilities, configure authentication, and execute your Selenium 4 test sessions on real browsers hosted in the LambdaTest cloud.
+Migrating your Selenium 4 tests from BrowserStack to requires only a few small updates. In this guide, we’ll walk through how to apply ’s W3C-compliant capabilities, configure authentication, and execute your Selenium 4 test sessions on real browsers hosted in the cloud.
***
-### LambdaTest Automation Capabilities
+### Automation Capabilities
Capabilities generator let you configure the desired capabilities (or capabilities) which are configuration options that let you set the following:
@@ -118,10 +122,10 @@ Capabilities generator let you configure the desired capabilities (or capabiliti
Optionally, you can also choose the Selenium version and other advanced options present in the Selenium Capabilities Generator. For this migration guide, we have only restricted to the three capabilities listed above.
-To generate capabilities use [LambdaTest Capabilities Generator](https://www.lambdatest.com/capabilities-generator/) to define key automation testing parameters, such as browser, version, operating system, and additional test settings.
+To generate capabilities use [ Capabilities Generator](https://www.lambdatest.com/capabilities-generator/) to define key automation testing parameters, such as browser, version, operating system, and additional test settings.
-For the migration, we have considered Java-based Selenium automation tests. Shown below are the screenshots of capabilities generator of BrowserStack and LambdaTest:
+For the migration, we have considered Java-based Selenium automation tests. Shown below are the screenshots of capabilities generator of BrowserStack and :
@@ -141,7 +145,7 @@ capabilities.setCapability("bstack:options", bstackOptions);
-
+
```js
SafariOptions browserOptions = new SafariOptions();
@@ -161,12 +165,12 @@ browserOptions.setCapability("LT:Options", ltOptions);
-## Configuring Selenium 3 Tests on LambdaTest
+## Configuring Selenium 3 Tests on
***
-Migrating your Selenium 3 tests from BrowserStack to LambdaTest requires only a few simple configuration changes. In the sections below, we’ll guide you through updating your test setup, applying Selenium 3–compatible capabilities, and running your test sessions on real browsers hosted on the LambdaTest cloud.
+Migrating your Selenium 3 tests from BrowserStack to requires only a few simple configuration changes. In the sections below, we’ll guide you through updating your test setup, applying Selenium 3–compatible capabilities, and running your test sessions on real browsers hosted on the cloud.
***
-### LambdaTest Automation Capabilities
+### Automation Capabilities
The Capabilities Generator allows you to configure the required desired capabilities for Selenium 3 test execution. These capabilities define the browser environment in which your tests will run.
@@ -178,9 +182,9 @@ With Selenium 3, the core capabilities remain:
Optionally, you may also configure Selenium versions or other advanced settings based on your test requirements. However, for this migration guide, we will primarily focus on the three fundamental capabilities listed above.
-To generate capabilities for Selenium 3, you can use the [LambdaTest Capabilities Generator](https://www.lambdatest.com/capabilities-generator/) , which allows you to define essential automation parameters such as browser name, browser version, operating system, along with any additional test configurations required for execution.
+To generate capabilities for Selenium 3, you can use the [ Capabilities Generator](https://www.lambdatest.com/capabilities-generator/) , which allows you to define essential automation parameters such as browser name, browser version, operating system, along with any additional test configurations required for execution.
-Below are example capability representations from BrowserStack and LambdaTest to help you understand how to adapt your existing configuration during migration.
+Below are example capability representations from BrowserStack and to help you understand how to adapt your existing configuration during migration.
@@ -199,7 +203,7 @@ caps.setCapability("browserstack.key", "YOUR_ACCESS_KEY");
-
+
```js
DesiredCapabilities capabilities = new DesiredCapabilities();
@@ -220,18 +224,18 @@ capabilities.setCapability("LT:Options", ltOptions);
-## Hands On Guide - LambdaTest Migration
+## Hands On Guide - Migration
***
-Let’s walk through a practical example demonstrating how to migrate a Selenium 4 test to LambdaTest. In this scenario, we launch the latest Chrome browser on a Windows 10 machine.
+Let’s walk through a practical example demonstrating how to migrate a Selenium 4 test to . In this scenario, we launch the latest Chrome browser on a Windows 10 machine.
**Test Scenario**:
-This test script performs a basic text validation on the website [LambdaTest eCommerce Playground](https://ecommerce-playground.lambdatest.io/) and shows the expected execution results when running the test in the LambdaTest cloud.
+This test script performs a basic text validation on the website [ eCommerce Playground](https://ecommerce-playground.lambdatest.io/) and shows the expected execution results when running the test in the cloud.
-
+
```java
// TextValidationTest.java
@@ -298,7 +302,7 @@ public class TextValidationTest {
-
+
```java
// TextValidationTest.java – Selenium 3 Configuration
@@ -368,7 +372,7 @@ public class TextValidationTest {
**Result**
-Visit LambdaTest Web Automation dashboard to view your test execution result.
+Visit Web Automation dashboard to view your test execution result.
@@ -379,19 +383,19 @@ Visit LambdaTest Web Automation dashboard to view your test execution result.
\ No newline at end of file
+
diff --git a/docs/bug-tracking-tools.md b/docs/bug-tracking-tools.md
index 9cbd107c4..f7b8c20b7 100644
--- a/docs/bug-tracking-tools.md
+++ b/docs/bug-tracking-tools.md
@@ -2,23 +2,26 @@
id: bug-tracking-tools
title: Bug Tracking Tools
sidebar_label: Integrations
-description: LambdaTest offers integrations with numerous Bug Tracking tools to help you mark and track bugs for pacing up your debugging.
+description: TestMu AI offers integrations with numerous Bug Tracking tools to help you mark and track bugs for pacing up your debugging.
keywords:
- - lambdatest integrations
- - lambdatest integrations with bug tracking tools
+ - testmu ai integrations
+ - testmu ai integrations with bug tracking tools
- bug marking tools
- bug tracking tools
- debugging
-url: https://www.lambdatest.com/support/docs/bug-tracking-tools/
-site_name: LambdaTest
+url: https://www.testmuai.com/support/docs/bug-tracking-tools/
+site_name: TestMu AI
slug: bug-tracking-tools/
+canonical: https://www.testmuai.com/support/docs/bug-tracking-tools/
---
import CodeBlock from '@theme/CodeBlock';
import {YOUR_LAMBDATEST_USERNAME, YOUR_LAMBDATEST_ACCESS_KEY} from "@site/src/component/keys";
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+
-# Integrate with LambdaTest to report and track bugs
+# Integrate with to report and track bugs
---
:::info Note
@@ -142,12 +145,12 @@ If your favourite Bug Tracking tool is not in the list above mentioned, you can
\ No newline at end of file
+
diff --git a/docs/bugasura-integration.md b/docs/bugasura-integration.md
index 4d0197072..6e5618395 100644
--- a/docs/bugasura-integration.md
+++ b/docs/bugasura-integration.md
@@ -3,15 +3,19 @@ id: bugasura-integration
title: Bugasura Integration
hide_title: true
sidebar_label: Bugasura
-description: Integrate LambdaTest with Bugasura for efficient one-click bug logging of your web applications and avoid the hassle of maintaining bugs and tasks manually.
+description: Integrate TestMu AI with Bugasura for efficient one-click bug logging of your web applications and avoid the hassle of maintaining bugs and tasks manually.
keywords:
- - lambdatest integration with bugasura
- - lambdatest and bugasura integration
+ - testmu ai integration with bugasura
+ - testmu ai and bugasura integration
- bugasura integration
-url: https://www.lambdatest.com/support/docs/bugasura-integration/
-site_name: LambdaTest
+url: https://www.testmuai.com/support/docs/bugasura-integration/
+site_name: TestMu AI
slug: bugasura-integration/
+canonical: https://www.testmuai.com/support/docs/bugasura-integration/
---
+import BrandName, { BRAND_URL } from '@site/src/component/BrandName';
+import { CookieTrackingSignup } from '@site/src/component/CookieTracking';
+
and Bugasura integration, you can file bugs while performing [online browser testing](https://www.lambdatest.com) of your web applications from the platform to your Bugasura instance and avoid the hassle of maintaining bugs and tasks manually.
-## Integrating Bugasura With LambdaTest
+## Integrating Bugasura With
***
:::info Note
Before enabling integrations, ensure you have administrator or user level access.
:::
-1. Sign in to your LambdaTest account. Don't have an account, [register for free](https://accounts.lambdatest.com/register).
+1. Sign in to your account. Don't have an account, register for free.
2. Select **Integrations** from the left sidebar and then **Bugasura**.
@@ -77,12 +81,12 @@ Before enabling integrations, ensure you have administrator or user level access
-The Bugasura will be integrated with your LambdaTest account.
+The Bugasura will be integrated with your account.
## One-Click Bug Logging With Bugasura
***
-1. Once you are in the LambdaTest Dashboard, navigate to **Real Time Testing > Browser Testing** from the left sidebar menu.
+1. Once you are in the Dashboard, navigate to **Real Time Testing > Browser Testing** from the left sidebar menu.
2. To perform live-interactive testing of your website or a web app, enter the web URL, select testing type (Desktop/Mobile), select the browser **VERSION**, **OS**, **RESOLUTION**, and click **START**.
@@ -102,7 +106,7 @@ A cloud-based virtual machine will fire up running real browsers and operating s
-6. Visit LambdaTest Dashboard. From the left sidebar menu, select **Manage > Issue Tracker**.
+6. Visit Dashboard. From the left sidebar menu, select **Manage > Issue Tracker**.
8. In Issue Tracker, you'll notice the logged bugs along with their test environment details. To view your logged bugs in Bugasura, click **upper right arrow in square** button.
@@ -116,7 +120,7 @@ It will re-direct you to the Bugasura dashboard where you can find your filed bu
## Uninstalling The Bugasura Integration
***
-1. Sign in to your LambdaTest account and visit **Integrations** from the left sidebar menu.
+1. Sign in to your account and visit **Integrations** from the left sidebar menu.
2. From **My Integrations**, click **REMOVE** under the Bugasura block.
@@ -126,12 +130,12 @@ It will re-direct you to the Bugasura dashboard where you can find your filed bu
@@ -113,9 +114,9 @@ Below given is the list of Camera APIs which are supported by LambdaTest Image I
This section explains how to use Image Injection with App automation. This section will also teach you how to use image injection for all the possible test cases for your app along with other useful information.
-### Step 1: Upload image to LambdaTest
+### Step 1: Upload image to
-You can use the following curl command to upload any image of your choice to the LambdaTest cloud. Please note that we support only **JPG, JPEG, and PNG formats which can be 10 MB or less**.
+You can use the following curl command to upload any image of your choice to the
cloud. Please note that we support only **JPG, JPEG, and PNG formats which can be 10 MB or less**.