' \
+--header 'Content-Type: application/json' \
+--data-raw '{
+ "testSuite": "lt://App_id",
+ "device": ["iPhone.*-16","iPhone 14-16","iPhone 15-17"],
+ "video": true,
+ "deviceLog": true,
+ "queueTimeout": 9000,
+ "network": true,
+ "build": "Flutter iOS - Parallel"
+}'
+```
+
+
+**Do note that Flutter builds when run in parallel, result in separate builds being generated for each parallel run.**
+
+
diff --git a/docs/getting-started-with-hyperexecute.mdx b/docs/getting-started-with-hyperexecute.mdx
new file mode 100644
index 000000000..c4e9a7476
--- /dev/null
+++ b/docs/getting-started-with-hyperexecute.mdx
@@ -0,0 +1,129 @@
+---
+title: "Getting Started with HyperExecute"
+sidebarTitle: "Introduction"
+description: "Get started with HyperExecute on TestMu AI for faster web automation tests using Matrix and Auto-Split strategies. Test with Selenium languages at high speeds."
+keywords: ['testmu ai automation', 'testmu ai hyperexecute', 'hyperexecute automation grid', 'hyperexecute online', 'online hyperexecute', 'hyperexecute automation grid online', 'testmu ai hypterest tutorial', 'hyperexecute getting started', 'testmu ai hyperexecute getting started', 'hyperexecute automation testing', 'hyperexecute matrix execution', 'hyperexecute autosplit execution', 'hyperexecute auto-split execution']
+"og:description": "Get started with HyperExecute on TestMu AI for faster web automation tests using Matrix and Auto-Split strategies. Test with Selenium languages at high speeds."
+---
+
+import { FrameworkGridHyperexecute } from '/snippets/FrameworkGridHyperexecute.mdx';
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Welcome to HyperExecute, **an AI-Native Test Orchestration Cloud Platform**, designed to accelerate your testing process, enabling test automation teams worldwide to achieve an accelerated time to market by providing **JIT (Just-in-time) testing infrastructure**.
+
+If you want to learn more about HyperExecute and how it can enable your team, then you are the right place. This guide will help you take your first steps with HyperExecute, from understanding the basics to running your first test.
+
+{/* HyperExecute is an AI Native Test Orchestration Cloud Platform, enabling test automation teams worldwide to achieve an accelerated time to market by providing JIT (Just-in-time) testing infrastructure that offers enhanced test execution speeds, smart test orchestration, detailed execution logs and much more. */}
+
+{/* It requires a [HyperExecute YAML](/support/docs/deep-dive-into-hyperexecute-yaml/) file which contains all the necessary instructions and a [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/) in order to initiate a test execution Job. */}
+
+{/* > Let's understand the [HyperExecute Dashboard](/support/docs/hyperexecute-guided-walkthrough/) together. */}
+
+
+
+## What is HyperExecute?
+
+HyperExecute by is a cutting-edge, AI-powered platform designed for DevOps teams and QA engineers to significantly accelerate software testing pipelines. HyperExecute **replaces traditional hub-and-node test grids** with advanced orchestration techniques, **eliminating network latency and optimizing resource usage**. With HyperExecute:
+
+ - **Slash your time-to-market** with parallel execution that distributes tests optimally across available resources improving efficiency.
+ - **Make data-driven testing decisions** using historical performance trends that reveal patterns and help optimize your testing strategy
+ - **Never worry about infrastructure constraints** with dynamic scaling to handle peak testing demands, running 10 tests or 10,000.
+ - **Enable multiple teams using different frameworks** to run tests simultaneously across various environments on same license.
+ {/* - **Intelligent Test Distribution**: Smart test allocation ensures optimal execution efficiency. */}
+ {/* - **Real-Time Insights**: Access immediate feedback with comprehensive live logs and detailed execution analytics. */}
+ {/* - **On-Demand Scalability**: Dynamically scale testing infrastructure to handle any volume or complexity of tests. */}
+ {/* - **Seamless Integration**: Effortlessly integrate with major CI/CD pipelines and testing frameworks for streamlined workflows. */}
+
+Whether testing web or mobile applications, HyperExecute empowers your team to deliver higher-quality software rapidly and reliably.
+
+## Compatible with All Major Frameworks
+HyperExecute seamlessly supports all major test automation frameworks as shown below. Regardless of your existing testing stack, it will integrate smoothly to enhance your workflows without disruption.
+
+
+
+## Let's Run your First Test
+Ready to experience the power of HyperExecute? Getting started is easy—we’ve simplified the process so you can effortlessly launch your first test with three flexible approaches and experience the speed by yourself:
+
+
+**RUN SAMPLE TEST**
+
+
+
+ Execute tests directly from the HyperExecute Portal with sample setup - perfect for new users who want to see results immediately.
+
+
Learn More
+
+
+
+ Run tests from your own machine using the HyperExecute CLI with sample project and preset configuration file.
+
+
Learn More
+
+
+ Run your tests in a fully managed online development environment, without any local installations or configurations.
+
+
Learn More
+
+
+
+
+{/* Each method provides a streamlined experience with sample projects. Our step-by-step guide walks you through the entire process, from selecting your framework to viewing your test results on the HyperExecute Dashboard. */}
+
+## Watch HyperExecute in Action
+
+Get a comprehensive overview of HyperExecute's capabilities by watching our introductory webinar.
+
+
+## Next Steps
+
+Now that you've set up HyperExecute and run your first test, explore these resources to make the most of the platform:
+
+
+
+ A step-by-step walkthrough of how to run your first job on the HyperExecute Platform.
+
+
+ Understand how you can initiate jobs using our CLI from your local setup or CI/CD pipelines.
+
+
+ Learn about the different configurations & creating a YAML suited for your needs.
+
+
+ Everything you need to know about HyperExecute status and what does it implies.
+
+
+ Learn about the different features and how you can use them in your project.
+
+
+ Understand how we expedite test execution as compared to traditional grids.
+
+
+ Learn how to setup HyperExecute Private Cloud for your organization.
+
+
+ Know how to setup with your CI/CD, Project management tools and products.
+
+
+
+
+**We’re Already in Your Favorite Cloud!**
+
+Deploy our cloud-native test orchestration platform directly from your trusted marketplace:
+- [Microsoft Azure Marketplace](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/lambdatestinc1584019832435.hyper_execute?exp=ubp8&tab=Overview)
+- [Amazon Web Services Marketplace](https://aws.amazon.com/marketplace/pp/prodview-35cneaxfou2eq)
+- [Google Cloud Provider Marketplace](https://console.cloud.google.com/marketplace/product/hyperexecute-privatecloud/lambdatest?pli=1)
+
+
+{/* Here are all the languages and frameworks supported by HyperExecute. */}
+
+{/* > HyperExecute supports multiple languages and testing frameworks. See the comprehensive list & samples [here](/support/docs/hyperexecute-supported-languages-and-frameworks/). */}
diff --git a/docs/getting-started-with-kane-ai.mdx b/docs/getting-started-with-kane-ai.mdx
index 5df749eb7..2a7ff705a 100644
--- a/docs/getting-started-with-kane-ai.mdx
+++ b/docs/getting-started-with-kane-ai.mdx
@@ -1,6 +1,6 @@
---
title: "Introduction to KaneAI"
-sidebarTitle: "Introduction to KaneAI"
+sidebarTitle: "Introduction"
description: "World's first GenAI-Native testing assistant that simplifies end-to-end automation testing for web, mobile, and cloud apps, using natural language."
keywords: ['ai testing tool', 'ai qa agent', 'genai qa agent', 'testmu ai automation', 'testmu ai kaneai', 'kaneai', 'use cases of kaneai']
"og:description": "World's first GenAI-Native testing assistant that simplifies end-to-end automation testing for web, mobile, and cloud apps, using natural language."
@@ -28,13 +28,13 @@ With KaneAI you can:
If you are new to KaneAI, you can learn more about how to use KaneAI by following guides:
-
+
Author your first Browser test on Desktop device.
-
+
Author your first Browser test on Mobile device.
-
+
Author your first Mobile App test.
@@ -43,10 +43,10 @@ If you are new to KaneAI, you can learn more about how to use KaneAI by followin
Learn what is the best way to tell KaneAI what it needs to do:
-
+
KaneAI works best with specific types of commands. Learn which commands are supported and how to use them effectively.
-
+
Assertions make your test validations more seamless and effective, learn how to use assertions with KaneAI.
diff --git a/docs/getting-started-with-lambdatest-automation.mdx b/docs/getting-started-with-lambdatest-automation.mdx
new file mode 100644
index 000000000..43ea795a5
--- /dev/null
+++ b/docs/getting-started-with-lambdatest-automation.mdx
@@ -0,0 +1,58 @@
+---
+title: "Get Started With Selenium Testing"
+sidebarTitle: "Overview"
+keywords: ['testmu ai automation', 'selenium automation grid', 'selenium grid online', 'online selenium automation', 'selenium automation grid online', 'testmu ai selenium automation grid', 'selenium tutorial', 'selenium getting started', 'testmu ai getting started']
+description: "Run Selenium tests on TestMu AI's cloud grid. 3000+ browser and OS combinations, parallel execution, video recordings, and built-in debugging."
+"og:description": "Run Selenium tests on TestMu AI's cloud grid. 3000+ browser and OS combinations, parallel execution, video recordings, and built-in debugging."
+---
+
+---
+
+Run your Selenium tests on TestMu AI's cloud grid of 3000+ browser and OS combinations. Point your tests at the hub URL, add capabilities, and get parallel execution, video recordings, logs, and screenshots for every session - no infrastructure to maintain.
+
+
+## Before You Begin
+---
+
+1. You need a TestMu AI account. [Sign up free](https://www.testmuai.com/register/) if you don't have one.
+2. Visit the [TestMu AI Dashboard](https://www.testmuai.com/login/?redirectTo=https://accounts.lambdatest.com/dashboard) and navigate to the left sidebar and select **Credentials**. Your **Username** and **Access Key** will be visible there, along with options to copy them for use.
+3. Set them as environment variables:
+
+
+
+ ```bash
+ export LT_USERNAME="YOUR_USERNAME"
+ export LT_ACCESS_KEY="YOUR_ACCESS_KEY"
+ ```
+
+
+ ```powershell
+ set LT_USERNAME="YOUR_USERNAME"
+ set LT_ACCESS_KEY="YOUR_ACCESS_KEY"
+ ```
+
+
+
+Your tests connect to the grid at:
+
+```
+https://{username}:{accessKey}@hub.lambdatest.com/wd/hub
+```
+
+## Choose How to Start
+---
+
+
+
+ New to cloud testing? Clone a sample project, set credentials, and run your first Selenium script on the grid.
+
+
+ Already have Selenium tests? Change the hub URL, add credentials, and run them on the cloud.
+
+
+ See where test results live - video playback, command logs, screenshots, and analytics.
+
+
+ Control which browser, version, OS, and advanced features your tests use.
+
+
diff --git a/docs/getting-started-with-mobile-app-real-time-testing.mdx b/docs/getting-started-with-mobile-app-real-time-testing.mdx
new file mode 100644
index 000000000..fea5dec79
--- /dev/null
+++ b/docs/getting-started-with-mobile-app-real-time-testing.mdx
@@ -0,0 +1,39 @@
+---
+title: "Getting started with Mobile App Real Time Testing"
+sidebarTitle: "Run Your First Mobile App Test"
+description: "Test your mobile apps on real devices in real-time with TestMu AI. Easily launch virtual machines and test across various OS and versions."
+keywords: ['real time testing in testmu ai', 'testmu ai real time testing feature', 'online real time testing', 'free cross browser testing tool', 'cross browser compatibility testing tool', 'online real time website testing', 'test website in different screen sizes', 'ie browser compatibility testing tool', 'test on gionee elfie e7 online', 'test on mac 10.11 el capitan online', 'apple mac el capitan virtual machine']
+"og:description": "Test your mobile apps on real devices in real-time with TestMu AI. Easily launch virtual machines and test across various OS and versions."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Real-Time Mobile App Testing allows you to test mobile applications directly on real devices in real time. It ensures that your app functions as intended, performs optimally, and provides a seamless user experience across various mobile operating systems such as Android and iOS. With , developers, testers, and QA professionals can interact with their mobile applications as end users would, on actual devices, without needing to manage an in-house device lab.
+
+## Launch the Virtual Machine
+
+- Navigate to the Real Time Testing section.
+- Select **Virtual Mobile** from the **App Testing** section.
+- To test your application, enter its URL or upload your application from your local machine and select your **Device** - Andoroid, iOS, or [ChromeOS](/support/docs/chrome-os-testing/), and its version.
+- Afterwards click on the **Start** button to initiate the testing process.
+
+
+
+## Dashboard Walkthrough
+The Real-Time Testing dashboard provides an intuitive interface for managing your testing sessions:
+
+- **Operating System Tabs :** Located at the top, this section allows you to toggle between different operating systems (Android, and iOS).
+
+- **Device Selection Panel :** Allows you to filter devices by operating system (Android or iOS), manufacturer, and model. Lists popular devices, including the latest models, to test on.
+
+- **Upload Apps :** In the dashboard, there is a section for uploading your mobile application. You can either:
+ - **Provide a URL :** Use this if the app is hosted online or accessible via a direct link.
+ - **Upload from Local System :** Use this option to upload the application file (APK/IPA) from your computer.
+
+- **Tunnel :** For testing on environments that are not publicly accessible, configure the Tunnel settings to enable testing on staging or local sites.
+
+- **Switch to Real Devices :** If you need to perform tests on physical devices, click on the Switch to Real Devices link to access 's real device cloud.
+
+- **Start Button :** Located on the right side of the URL field, this button initializes the testing session once you have chosen your device and browser configuration.
diff --git a/docs/getting-started-with-mobile-browser-real-time-testing.mdx b/docs/getting-started-with-mobile-browser-real-time-testing.mdx
new file mode 100644
index 000000000..5045903d5
--- /dev/null
+++ b/docs/getting-started-with-mobile-browser-real-time-testing.mdx
@@ -0,0 +1,39 @@
+---
+title: "Getting started with Mobile Web Browser Real Time Testing"
+sidebarTitle: "Run Your First Mobile Browser Test"
+description: "Test your websites on real mobile browsers with TestMu AI's Real-Time Mobile Web Browser Testing. Easily launch virtual machines and test across various OS, browsers, and versions."
+keywords: ['real time testing in testmu ai', 'testmu ai real time testing feature', 'online real time testing', 'free cross browser testing tool', 'cross browser compatibility testing tool', 'online real time website testing', 'test website in different screen sizes', 'ie browser compatibility testing tool', 'test on gionee elfie e7 online', 'test on mac 10.11 el capitan online', 'apple mac el capitan virtual machine']
+"og:description": "Test your websites on real mobile browsers with TestMu AI's Real-Time Mobile Web Browser Testing. Easily launch virtual machines and test across various OS, browsers, and versions."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Real-Time Mobile Web Browser Testing allows you to test websites and web applications across different mobile browsers and operating systems, such as Android, iOS, and ChromeOS, in real-time. This process helps ensure that your web applications are fully functional, visually consistent, and optimized for various mobile devices, enhancing the user experience across different platforms. Using , developers, testers, and QA professionals can validate their web applications without the need for physical devices, all from a unified, user-friendly interface.
+
+## Launch the Virtual Machine
+
+- Navigate to the Real Time Testing section.
+- Select **Virtual Mobile** from the **Web Browser Testing** section.
+- To test a website, enter its URL and select your **Device** - Andoroid, iOS, or [ChromeOS](/support/docs/chrome-os-testing/), and its version.
+- Afterwards click on the **Start** button to initiate the testing process.
+
+
+
+## Understanding the Dashboard
+The dashboard is designed to simplify the testing process. Here's a breakdown of its key components:
+
+- **Operating System Tabs :** Located at the top, this section allows you to toggle between different operating systems (Android, iOS, and ChromeOS).
+
+- **Browser Selection :** Below the OS tabs, a dropdown lets you choose the browser you want to test on. Available options may vary depending on the selected OS.
+
+- **Device Selection Pane :** This panel lists the available devices manufacturers and models. You can quickly search for a device using the search bar, or filter by manufacturer (e.g., Samsung, Google, Apple). The list also displays the OS version supported for each device.
+
+- **URL Field :** The top portion of the dashboard provides a field to enter the target URL.
+
+- **Switch to Real Devices :** If you need to perform tests on physical devices, click on the Switch to Real Devices link to access 's real device cloud.
+
+- **Tunnel :** For testing on environments that are not publicly accessible, configure the Tunnel settings to enable testing on staging or local sites.
+
+- **Start Button :** Located on the right side of the URL field, this button initializes the testing session once you have chosen your device and browser configuration.
diff --git a/docs/getting-started-with-selenium-4.mdx b/docs/getting-started-with-selenium-4.mdx
new file mode 100644
index 000000000..995cb735c
--- /dev/null
+++ b/docs/getting-started-with-selenium-4.mdx
@@ -0,0 +1,87 @@
+---
+title: "Getting Started With Selenium 4 On TestMu AI Platform"
+sidebarTitle: "Getting Started"
+description: "Now run automated tests with Selenium 4 using the TestMu AI Selenium Grid across 3000+ browsers and operating systems."
+keywords: ['selenium 4', 'selenium 4 relative locators', 'selenium 4 automation', 'selenium 4 documentation']
+"og:description": "Now run automated tests with Selenium 4 using the TestMu AI Selenium Grid across 3000+ browsers and operating systems."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+## Introduction
+
+
+Now run automated tests with Selenium 4 using the Selenium Grid across 3000+ browsers and operating systems. With this and Selenium 4 integration, not only allows you to perform Selenium 4 testing on an online automation cloud, but also allows you to perform cross-browser testing at scale.
+
+This Selenium 4 documentation will act as your step-by-step guide on your journey to test using Selenium 4 on .
+
+
+: As of now, the sample test script is only available in Java. But worry not! We are working on adding the test scripts on other languages too.
+
+
+
+## Running Your First Test
+
+* * *
+
+As a part of this step-by-step guide, we will run a Selenium 4 test that perform the following action:
+
+1. Open **google.com.**
+2. Enter a search string in the browser.
+3. Click the **Google Search** button.
+4. Assert the page URL.
+5. Mark the status of the test as either passed or failed based on the assertion.
+
+### Step 1 - OS-device-browser Combination
+
+* * *
+
+To select the OS-device-browser combination for running the test, use 's [capability generator](https://www.testmuai.com/capabilities-generator/). After selecting the combination, replace the capabilities given in the sample test script with the chosen combination.
+
+### Step 2 - Understanding the Sample Script
+
+* * *
+
+As the sample test script is only available in Java, we recommend using it to run your first Selenium 4 test on . The offered test script uses the updated Action class features and the relative locators of Selenium 4.
+
+**Relative Locators** helps users locate any complex UI elements, elements that might be relevant to a critical UI element, in fewer lines of code. Selenium 4 has the following relative locators: `above`, `below`, `toLeftOf`, `toRightOf`, and `near`. For the sake of this test, the script uses the `toLeftof` locator to locate the Google Search button on the Google home page.
+
+Some other use cases for Relative Locators are:
+
+- In the case of an e-commerce website, relative locators can help identify a particular button if there are multiple buttons with the same name on a single website page.
+- UI elements that do not include unique IDs
+- UI elements with complex CSS or XPath expression.
+
+Selenium 4 comes with a changed syntax of the **Action class**. It is used for handling mouse and keyboard events on a specific element. For this test, the script uses the `moveToElement(onElement).click()` method to simulate the click action of your mouse.
+
+Along with these features, Selenium 4 offers other CDP features that supports. Check them out now.
+
+### Step 3 - Writing the Sample Test Script
+
+* * *
+
+In your Java project, create a new file JavaSample.java and copy the following code to this file:
+
+
+: As of now, the sample test script is only available in Java. But worry not! We are working on adding the test scripts on other languages too.
+
+
+
+
+: Ensure that you include the driver.quit() statement at the end of the test script to avoid timeout issues. If you skip adding the statement, the test continues to run leading to a timeout.
+
+
+
+### Step 4 - Run the Sample Test Code
+
+* * *
+
+You can run the file using the Run command in your IDE after the test script is created.
+
+### Step 5 - View the Test Results
+
+* * *
+
+After running the test successfully, the dashboard and the command line will view your result. In addition, you get access to text logs, video recordings ,and screenshots of your test execution.
diff --git a/docs/getting-started-with-testmu-automation.mdx b/docs/getting-started-with-testmu-automation.mdx
new file mode 100644
index 000000000..02c307e90
--- /dev/null
+++ b/docs/getting-started-with-testmu-automation.mdx
@@ -0,0 +1,28 @@
+---
+title: "Selenium Automation Testing Using TestMu AI"
+sidebarTitle: "Overview"
+description: "Guide to getting started with TestMu AI online Selenium automation grid. Run Selenium scripts on an online Selenium automation grid of 3000+ browsers. Run test on Java, Javascript, and 7 other programming language."
+keywords: ['testmu ai automation', 'selenium automation grid', 'selenium grid online', 'online selenium automation', 'selenium automation grid online', 'testmu ai selenium automation grid', 'selenium tutorial', 'selenium getting started', 'testmu ai getting started']
+"og:description": "Guide to getting started with TestMu AI online Selenium automation grid. Run Selenium scripts on an online Selenium automation grid of 3000+ browsers. Run test on Java, Javascript, and 7 other programming language."
+---
+
+import { SeleniumSupportedLanguage } from '/snippets/SeleniumSupportedLanguage.mdx';
+import { BrandName } from "/snippets/BrandName.mdx";
+
+ provides a robust and versatile Selenium Automation Grid, designed to revolutionize your [cross browser testing](https://www.lambdatest.com/) process. This powerful platform enables you to perform comprehensive, efficient, and scalable automated tests across a vast array of browsers and operating systems.
+
+## Key Features
+
+- Access to **3000+ browsers** and **operating systems**.
+- Secure and reliable infrastructure
+- Faster build times and higher test coverage
+- **Local testing support** via [ Tunnel](/support/docs/testing-locally-hosted-pages/)
+- Simultaneous testing across multiple configurations
+
+## Supported Languages and Frameworks
+
+
+
+
+We support all languages and frameworks that are compatible with Selenium, so in case your favorite isn't in the table.
Don't worry, you can still run the test. window.openLTChatWidget()}>Contact Us for any help.
+
diff --git a/docs/getting-started-with-xcuitest.mdx b/docs/getting-started-with-xcuitest.mdx
new file mode 100644
index 000000000..e2a4d40f9
--- /dev/null
+++ b/docs/getting-started-with-xcuitest.mdx
@@ -0,0 +1,192 @@
+---
+title: "XCUI Testing on TestMu AI"
+sidebarTitle: "XCUI Testing"
+description: "Master XCUITest automation with TestMu AI! Learn to run scripts, utilize capabilities, and execute tests on real iOS devices effortlessly. Get started now!"
+keywords: ['xcuitest', 'app test automation', 'testmu ai xcuitest', 'framework on testmu ai', 'app testing xcuitest', 'app testing', 'real devices']
+"og:description": "Master XCUITest automation with TestMu AI! Learn to run scripts, utilize capabilities, and execute tests on real iOS devices effortlessly. Get started now!"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+import { RealDeviceTag } from '/snippets/RealDeviceTag.mdx';
+import { VirtualDeviceTag } from '/snippets/VirtualDeviceTag.mdx';
+
+
+
+Developed by Apple, XCUITest is a framework for user-interface (UI) testing for iOS applications. It is built on top of XCTest, an integrated test framework in Apple's Xcode IDE. lets you perform automated app testing of your iOS apps using XCUITest across 10000+ real devices and OS combinations.
+
+## Prerequisites
+
+- Your [Username and Access key](https://accounts.lambdatest.com/security).
+- Access to an **iOS** app (.ipa) and an **XCUI Test** app (.ipa file).
+
+
+**If you do not have any **iOS** app (.ipa) and an **XCUI Test** app (.ipa) file, you can run your sample tests on by using our sample 🔗 [iOS app](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_ios.ipa) and a sample 🔗 [XCUI Test](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_ios_xcuitest.ipa).**
+
+
+
+## Running Your First Test: A Step-by-Step Guide
+
+### Step 1: Upload Your Application
+
+To begin testing, upload your iOS application (.ipa file) to 's servers. You'll use our **REST API** for this process.
+
+- **Authentication :** You'll need your Username and AccessKey. Combine them in the format `Username:AccessKey`.
+- **Uploading the App :** Use **cURL command** to send a request to our API. The request should include the path to your application file (**appFile**).
+
+
+
+
+
+ ```bash
+
+ curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" --location --request POST 'https://manual-api.lambdatest.com/app/uploadFramework' --form 'appFile=@""' --form 'type="xcuit-ios"'
+
+```
+
+
+
+
+
+ ```powershell
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" -X POST "https://manual-api.lambdatest.com/app/uploadFramework" -F "appFile=@""" -F "type="xcuit-ios""
+
+```
+
+
+
+
+
+- Provide the path of your android application in the above URL in place of ``**
+
+- Response of above cURL will be a **JSON** object containing the `App URL` of the format - `lt://APP123456789123456789` and will be used in the last step.
+
+
+### Step 2: Upload Your Test Suite
+
+Upload your iOS test suite (.ipa) file to servers using our REST API.
+
+The following sample cURL command shows how to upload a test suite:
+
+
+
+
+
+ ```bash
+
+ curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" --location --request POST 'https://manual-api.lambdatest.com/app/uploadFramework' --form 'appFile=@""' --form 'type="xcuit-ios"'
+
+```
+
+
+
+
+
+ ```powershell
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" --location --request POST "https://manual-api.lambdatest.com/app/uploadFramework" --form "appFile=@""" --form "type=\"xcuit-ios\""
+
+```
+
+
+
+
+
+- Provide the path of your android application in the above URL in place of ``**
+
+- Response of above cURL will be a **JSON** object containing the `App URL` of the format - `lt://APP123456789123456789` and will be used in the last step.
+
+
+### Step 3: Executing The Test
+
+- You will need **base64 encoded authentication** in order to execute your Espresso automation test suite. Enter your `username:accesskey` in **[Basic Authentication Header Generator](https://mixedanalytics.com/knowledge-base/api-connector-encode-credentials-to-base-64/)** to generate your auth token.
+
+Take note of the base64 encoded authentication which needs to be added in the next step.
+
+```powershell
+
+YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY
+
+```
+
+- Once you have uploaded your app and test suite, you can execute your test by running the following command:
+
+
+Enter your **BASIC_AUTH_TOKEN**, **APP_ID** (generated in the first step) and **TEST_SUITE_ID** (generated in the second step) in the below command.
+
+
+
+
+
+
+```bash
+curl --location --request POST 'https://mobile-api.lambdatest.com/framework/v1/xcui/build' \
+--header 'Authorization: Basic BASIC_AUTH_TOKEN' \
+--header 'Content-Type: application/json' \
+--data-raw '{
+ "app" : "APP_ID",
+ "testSuite": "TEST_SUITE_ID",
+ "device" : ["iPhone 11-14"],
+ "video" : true,
+ "queueTimeout": 10800,
+ "idleTimeout": 150,
+ "devicelog": true,
+ "network": false,
+ "build" : "Proverbial-XCUITest"
+}'
+```
+
+
+
+
+
+```bash
+curl --location --request POST "https://mobile-api.lambdatest.com/framework/v1/xcui/build" \
+--header "Authorization: Basic BASIC_AUTH_TOKEN" \
+--header "Content-Type: application/json" \
+--data-raw "{
+ \"app\" : \"APP_ID\",
+ \"testSuite\": \"TEST_SUITE_ID\",
+ \"device\" : [\"iPhone 11-14\"],
+ \"video\" : true,
+ \"queueTimeout\": 10800,
+ \"idleTimeout\": 150,
+ \"devicelog\": true,
+ \"network\": false,
+ \"build\" : \"Proverbial-XCUITest\"
+}"
+```
+
+
+
+
+### Step 4: View Test Execution
+
+Once you have run your tests, you can view the test execution along with logs. You will be able to see the test cases passing or failing. You can view the same at [ Automation](https://accounts.lambdatest.com/login).
+
+
+
+## Running Tests in Parallel
+
+You can run tests in parallel on multiple devices by passing the device name in comma separated format in the execute command as show below:
+
+```bash
+curl --location --request POST 'https://mobile-api.lambdatest.com/framework/v1/xcui/build' \
+--header 'Authorization: Basic BASIC_AUTH_TOKEN' \
+--header 'Content-Type: application/json' \
+--data-raw '{
+ "app" : "APP_ID",
+ "testSuite": "TEST_SUITE_ID",
+ "device" : ["iPhone 11-14","iPhone 12 Pro-15","iPhone X-13"],
+ "queueTimeout": 10800,
+ "IdleTimeout": 150,
+ "deviceLog": true,
+ "build" : "Proverbial-XCUITest"
+}'
+```
+
+
+- For Virtual Devices, both the App file and Test-suite should be in the `Zip format`.
+
+- We need to pass the following capability `isvirtualdevice:true` as well when we are running test for Virtual Devices.
+
diff --git a/docs/ghost-inspector-integration-with-testmu.mdx b/docs/ghost-inspector-integration-with-testmu.mdx
new file mode 100644
index 000000000..c97e5c734
--- /dev/null
+++ b/docs/ghost-inspector-integration-with-testmu.mdx
@@ -0,0 +1,151 @@
+---
+title: "How To Integrate TestMu AI With Ghost Inspector?"
+sidebarTitle: "Ghost Inspector"
+description: "TestMu AI now integrates with Ghost Inspector 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: [ "TestMu AI integrations", "TestMu AI integrations with ci/cd tools", "ci/cd tools", "continuous integration", "continuous delivery", "continuous integration tools", "ghost inspector", "ghost inspector integration" ]
+"og:description": "TestMu AI now integrates with Ghost Inspector 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."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+***
+
+ provides support with Selenium WebDriver for pacing the execution of your automation test scripts. is a cloud-based, cross browser testing tool, providing a [Selenium Grid](https://www.lambdatest.com/selenium-automation/) of 3000+ browsers and browser versions running through real operating systems to speed up automation testing of your web-app or website. This topic will help you to automate your website testing using Ghost Inspector on .
+
+## What is Ghost Inspector?
+Ghost Inspector is a codeless automation tool that lets a software tester automate the process of writing test scripts.
+
+This integration between and Ghost Inspector enables you to automate the cross-browser testing process through the Selenium Grid of more than 2,000 browsers.
+
+As a result, you’ll be able to expand your test coverage, analyze and extract insightful test reports, and enhance your team collaboration.
+
+
+* * *
+* All the test suites will be reflected in the Ghost Inspector dashboard.
+
+
+
+
+
+* Click on the desired test suite.
+* Click on the desired test case under test suites.
+
+
+
+
+
+* Once you have selected the desired test case, click on **More** -> **Export Suite** and select the format as New Selenium IDE (.side).
+
+
+
+
+
+
+
+
+
+### Setup Selenium IDE Side Runner:
+
+* Node.js programming language (version 8 or 10).
+* NPM or Node.js Package Manager.
+* Selenium IDE Plugin, for either Google Chrome and Mozilla Firefox.
+* Selenium IDE (SIDE) Runner. You can download SIDE runner using below code:
+
+```bash
+npm install -g selenium-side-runner
+```
+* You also need your authentication credentials, which includes your username, and access key. These will be set up as the Secrets for configuring the pipeline. To get your Username and Access Key, go to your automation dashboard and click on the "key" icon left to the help button, on the top right corner.
+
+
+
+
+
+* Open Selenium IDE and click on ‘Open an existing project'.
+
+
+
+
+
+* Right click on the test suite and go to Settings. Test Suite Settings.
+
+
+
+
+
+* In the Settings window, tick the Run in Parallel checkbox. Test Suite Properties.
+
+
+
+
+
+* Save the SIDE project.
+* We have successfully activated Parallel Testing in Selenium IDE. Now we can execute tests Selenium IDE tests in parallel on Selenium Cloud Grid.
+
+## Executing Selenium IDE Tests on Selenium Cloud Grid
+***
+
+* Set the Desired Capabilities in Selenium. For this article, we have set the Chrome browser (version 72.0) for Windows 10, to run our Selenium IDE tests.
+* The Selenium Desired Capabilities Generator is used to generate the capabilities. Below are the desired capabilities used in this article for the required test combination, provided in Python Language.
+
+```bash
+capabilities = {
+ "platform" : "Windows 10",
+ "browserName" : "Chrome",
+ "version" : "72.0"
+ }
+```
+
+In the string format, it will be represented as:
+```bash
+ **"browserName='chrome' version='72.0' platform='Windows 10'"**
+ ```
+
+* Get the Grid URL for executing tests on . Get your username and access key from your 's Profile section (as shown in the prerequisites), and replace it in the below URL.
+
+```bash
+https://user-name:access-key@hub.lambdatest.com/wd/hub
+```
+
+* Specify the desired capabilities along with the Grid URL. Replace the desired capabilities and the Grid URL from the above steps in the below code:
+
+```bash
+selenium-side-runner --server --capabilities
+```
+* Mention the number of parallel processes to be executed at a time. You can use any of the below syntax to specify the count of parallel processes to be executed at the above mentioned Grid URL:
+
+```bash
+selenium-side-runner --w --server
+https://user-name:access-key@hub.lambdatest.com/wd/hub
+```
+
+OR
+
+```bash
+selenium-side-runner --max-workers --server
+https://user-name:access-key@hub.lambdatest.com/wd/hub
+```
+
+For this article, we have set the number of parallel processes as '4'.
+
+* Now we have all the components of the SIDE Runner command to execute the tests. So we will run the Selenium IDE tests on Selenium Cloud Grid. Navigate to the directory where the .SIDE file is located (here it is located at "-IDE.side") and execute the below command in the terminal, after replacing the GRID URL:
+
+```bash
+selenium-side-runner -w 4 "TestMu AI-IDE.side" --server
+https://user-name:acces-key@hub.lambdatest.com/wd/hub -c "browserName='chrome'
+version='72.0' platform='Windows 10'"
+```
+
+* We have successfully executed all the steps to run Selenium IDE tests on Selenium Cloud Grid. Now you can see our tests being executed along with their status in the Automation Timeline of your profile.
+
+* Below are the execution snapshots of the SIDE Runner and the automation timeline instance, that shows the successful execution of the desired tests: test execution snapshots automation test timeline.
+
+
+
+
+
+
+
+
+
diff --git a/docs/ghost-inspector-integration.mdx b/docs/ghost-inspector-integration.mdx
new file mode 100644
index 000000000..b333b0593
--- /dev/null
+++ b/docs/ghost-inspector-integration.mdx
@@ -0,0 +1,148 @@
+---
+title: "Ghost Inspector Integration With TestMu AI’s Cloud"
+sidebarTitle: "Ghost Inspector"
+description: "TestMu AI now integrates with Ghost Inspector 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: ['testmu ai integrations', 'testmu ai integrations with ci/cd tools', 'ci/cd tools', 'continuous integration,continuous delivery', 'continuous integration tools', 'ghost inspector', 'ghost inspector integration']
+"og:description": "TestMu AI now integrates with Ghost Inspector 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."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+ provides support with Selenium WebDriver for pacing the execution of your automation test scripts. is a cloud-based, cross browser testing tool, providing a [Selenium Grid](https://www.lambdatest.com/selenium-automation/) of 3000+ browsers and browser versions running through real operating systems to speed up automation testing of your web-app or website. This topic will help you to automate your website testing using Ghost Inspector on .
+
+## What is Ghost Inspector?
+Ghost Inspector is a codeless automation tool that lets a software tester automate the process of writing test scripts.
+
+This integration between and Ghost Inspector enables you to automate the cross-browser testing process through the Selenium Grid of more than 2,000 browsers.
+
+As a result, you’ll be able to expand your test coverage, analyze and extract insightful test reports, and enhance your team collaboration.
+
+# How To Integrate With Ghost Inspector?
+* * *
+* All the test suites will be reflected in the Ghost Inspector dashboard.
+
+
+
+
+
+* Click on the desired test suite.
+* Click on the desired test case under test suites.
+
+
+
+
+
+* Once you have selected the desired test case, click on **More** -> **Export Suite** and select the format as New Selenium IDE (.side).
+
+
+
+
+
+
+
+
+
+### Setup Selenium IDE Side Runner:
+
+* Node.js programming language (version 8 or 10).
+* NPM or Node.js Package Manager.
+* Selenium IDE Plugin, for either Google Chrome and Mozilla Firefox.
+* Selenium IDE (SIDE) Runner. You can download SIDE runner using below code:
+
+```bash
+npm install -g selenium-side-runner
+```
+* You also need your authentication credentials, which includes your username, and access key. These will be set up as the Secrets for configuring the pipeline. To get your Username and Access Key, go to your automation dashboard and click on the "key" icon left to the help button, on the top right corner.
+
+
+
+
+
+* Open Selenium IDE and click on ‘Open an existing project'.
+
+
+
+
+
+* Right click on the test suite and go to Settings. Test Suite Settings.
+
+
+
+
+
+* In the Settings window, tick the Run in Parallel checkbox. Test Suite Properties.
+
+
+
+
+
+* Save the SIDE project.
+* We have successfully activated Parallel Testing in Selenium IDE. Now we can execute tests Selenium IDE tests in parallel on Selenium Cloud Grid.
+
+## Executing Selenium IDE Tests on Selenium Cloud Grid
+***
+
+* Set the Desired Capabilities in Selenium. For this article, we have set the Chrome browser (version 72.0) for Windows 10, to run our Selenium IDE tests.
+* The Selenium Desired Capabilities Generator is used to generate the capabilities. Below are the desired capabilities used in this article for the required test combination, provided in Python Language.
+
+```bash
+capabilities = {
+ "platform" : "Windows 10",
+ "browserName" : "Chrome",
+ "version" : "72.0"
+ }
+```
+
+In the string format, it will be represented as:
+```bash
+ **"browserName='chrome' version='72.0' platform='Windows 10'"**
+ ```
+
+* Get the Grid URL for executing tests on . Get your username and access key from your 's Profile section (as shown in the prerequisites), and replace it in the below URL.
+
+```bash
+https://user-name:access-key@hub.lambdatest.com/wd/hub
+```
+
+* Specify the desired capabilities along with the Grid URL. Replace the desired capabilities and the Grid URL from the above steps in the below code:
+
+```bash
+selenium-side-runner --server --capabilities
+```
+* Mention the number of parallel processes to be executed at a time. You can use any of the below syntax to specify the count of parallel processes to be executed at the above mentioned Grid URL:
+
+```bash
+selenium-side-runner --w --server
+https://user-name:access-key@hub.lambdatest.com/wd/hub
+```
+
+OR
+
+```bash
+selenium-side-runner --max-workers --server
+https://user-name:access-key@hub.lambdatest.com/wd/hub
+```
+
+For this article, we have set the number of parallel processes as '4'.
+
+* Now we have all the components of the SIDE Runner command to execute the tests. So we will run the Selenium IDE tests on Selenium Cloud Grid. Navigate to the directory where the .SIDE file is located (here it is located at "-IDE.side") and execute the below command in the terminal, after replacing the GRID URL:
+
+```bash
+selenium-side-runner -w 4 "TestMu AI-IDE.side" --server
+https://user-name:acces-key@hub.lambdatest.com/wd/hub -c "browserName='chrome'
+version='72.0' platform='Windows 10'"
+```
+
+* We have successfully executed all the steps to run Selenium IDE tests on Selenium Cloud Grid. Now you can see our tests being executed along with their status in the Automation Timeline of your profile.
+
+* Below are the execution snapshots of the SIDE Runner and the automation timeline instance, that shows the successful execution of the desired tests: test execution snapshots automation test timeline.
+
+
+
+
+
+
+
+
diff --git a/docs/github-actions-with-hyperexecute.mdx b/docs/github-actions-with-hyperexecute.mdx
new file mode 100644
index 000000000..c692be1dd
--- /dev/null
+++ b/docs/github-actions-with-hyperexecute.mdx
@@ -0,0 +1,110 @@
+---
+title: "GitHub Actions Pipeline Integration with HyperExecute"
+sidebarTitle: "Run on GitHub Actions"
+description: "TestMu AI now integrates with GitHub Actions Pipeline 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: ['testmu ai integrations', 'testmu ai integrations with ci/cd tools', 'ci/cd tools', 'continuous integration,continuous delivery', 'continuous integration tools', 'github actions']
+"og:description": "TestMu AI now integrates with GitHub Actions Pipeline 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."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline. You can create workflows that build and test every pull request to your repository, or deploy merged pull requests to production.
+
+This document will show you how to integrate GitHub Actions Pipeline with HyperExecute to greatly shorten your test cycles.
+
+## How To Integrate GitHub Actions Pipeline with HyperExecute
+
+To integrate GitHub Actions Pipeline with HyperExecute, follow the below steps:
+
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+### 1. Log into your GitHub account
+- Navigate to the main page of the repository.
+- Under your repository name, click **Actions**.
+
+### 2. Create a New Workflow
+In the left sidebar, click the **New workflow** button.
+
+
+
+### 3. Create the GitHub Actions workflow YAML file
+
+To create the GitHub Actions pipeline YAML file, follow the sample command below:
+
+```yaml
+name: HyperExecute
+on:
+ workflow_dispatch:
+ inputs:
+ username:
+ required: true
+ description: LT Username
+ accessKey:
+ description: LT Access Key
+ required: true
+
+jobs:
+ HyperExecute:
+ runs-on: ubuntu-latest
+ timeout-minutes: 15
+ strategy:
+ fail-fast: false
+ steps:
+ - name: Checkout sources
+ uses: actions/checkout@v2
+
+ - name: Download CLI and Setting Environment Variables
+ shell: bash
+ run: |
+ curl https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute -o hyperexecute
+ chmod +x hyperexecute
+
+ - name: Executing the Job
+ shell: bash
+ run: |
+ ./hyperexecute --user ${{ github.event.inputs.username }} --key ${{ github.event.inputs.accessKey }} --download-artifacts --config yaml/autosplit_linux.yaml
+ echo "Test completion"
+```
+
+**Configuration breakdown:**
+
+- **on:**
+ - **workflow_dispatch:** In the **workflow_dispatch** section, you should declare the pre-defined variables that will be used before running the GitHub Actions Pipeline as an input.
+
+- **jobs:**
+ In the Jobs Section, declare the workflow of the pipeline execution.
+ - **runs-on:** Contains the value of the OS flavor you would like to execute the GitHub Actions Pipeline on.
+
+- **steps:**
+ In the steps section, you should declare the execution commands.
+ - The first step in the above sample YAML changes the path of the root directory.
+ - In the second step it downloads the HyperExecute CLI binary.
+ - The third step is the execution command which executes the HyperExecute CLI binary. This contains username, access key, and path of the YAML created for HyperExecute. You can find more information on this [here](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/).
+
+
+
+### 4. Run the Workflow
+To run the new pipeline that you just created, click the **Run workflow** button on the workflow page.
+
+
+
+**Below is an example of how a test that is run on the GitHub Actions pipeline gets executed:**
+
+
+
+**Below is an example of a HyperExecute job that was triggered through the above pipeline:**
+
+
+
+
+Run your tests at speeds never seen before. Happy testing!
+
diff --git a/docs/github-app-integration.mdx b/docs/github-app-integration.mdx
index 7c8298129..2751fa3ab 100644
--- a/docs/github-app-integration.mdx
+++ b/docs/github-app-integration.mdx
@@ -1,6 +1,6 @@
---
title: 'LamdaTest AI Cloud GitHub App Integration'
-sidebarTitle: 'KaneAI GitHub App Integration'
+sidebarTitle: "Validate PRs With the GitHub App"
keywords: ['github app','testmu ai integration','AI test generation','PR automation','test management']
---
diff --git a/docs/github-integration.mdx b/docs/github-integration.mdx
new file mode 100644
index 000000000..11eb4d8a2
--- /dev/null
+++ b/docs/github-integration.mdx
@@ -0,0 +1,156 @@
+---
+title: "GitHub Integration"
+sidebarTitle: "GitHub"
+keywords:
+ [
+ "lambdatest integrations",
+ "push issues to github",
+ "free cross browser testing tool"
+ ]
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+***
+
+GitHub is one of the most popular community among software developers. It helps you with version control by providing a code hosting platform for all. From open source to business, one can share their codes, discover new ideas and discuss about roadblocks, all in order to deliver a better software. GitHub also serves as a project management tool. It allows a team to collaborate from all around the globe.
+
+The GitHub Integration allows you to create a card directly in your repository from platform. Push an issue to your respective repository anytime, even in the middle of your test session. The fields populated by you when marking as bug through are displayed as information on the bug in GitHub repository for that testing instance.
+
+**GitHub Integration with , like all of our other integrations to 3rd party applications, is available as freemium as well as premium plan.**
+
+## How To Integrate GitHub With Your Account?
+***
+
+**Step 1:** Login to your account. You would need to have Admin or User level access to see and install integrations.
+
+**Step 2:** Select **‘Integrations’** 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 ‘Github’.
+
+
+
+**Step 4:** Step 4: Once you click on install, you’ll be redirected to a screen. There would be three options available for you to choose from in order to authenticate GitHub.
+
+### How To Integrate GitHub With Your Account Via OAuth?
+***
+**Step 1**: Select the radio button on **‘OAuth’** and click on **‘Install’**.
+
+
+
+You will be redirected to GitHub login page where you need to provide your login credentials.
+
+
+
+**Step 2**: Enter your GitHub login credentials and click on **‘Sign in’**.
+
+
+
+**Step 3**: You’ll be redirected to the OAuth permission page. Click on **‘Authorize ’**.
+
+
+**What is OAuth?**
+
+The purpose of OAuth is to bypass the authentication when two different applications interact using their respective APIs. GitHub APIs use OAuth 2.0’s authorization code grant flow for generating access tokens on the user’s behalf.
+
+
+
+That’s it! Go to Integrations again and you will be able to notice a green tick indicating that GitHub is successfully installed. You can now experience bug logging in a fly from any of your running test sessions in to your repository directly with a single click.
+
+
+
+### How To Integrate GitHub With Your Account Via Cloud?
+***
+
+**Step 1**: Select the radio button on **‘Cloud’**. This will ask you to enter your API token.
+
+
+**What is an API Token?**
+
+Access tokens are strings with an authorization key required to access an API. They are issued to the client-server and are usually opaque. They are used for requesting access to protected, user-specific resources. Access tokens are vital from a security point of view & can be generated in different formats, depending upon security requirements specified on the resource server.
+
+
+
+**Step 2**: Log in to your Github account and navigate to the **‘Settings’**.
+
+
+
+**Step 3**: Click on the **‘Developer Settings’** from the bottom-left.
+
+
+
+**Step 4**: Click on the **‘Personal access tokens’** from the left menu and click on **‘Generate new token’**.
+
+
+
+**Step 5**: Provide a token description, select the checkboxes for **‘repo’** & **‘user’** as scopes. These scopes will define the access to authenticate API over Basic OAuth for their respective personal token. After selecting the scopes click on **‘Generate token’**.
+
+
+
+**Step 6**: Your personal access token will be generated. Copy the generated token & store it safely with you, as you will not be able to see this token again.
+
+
+
+**Step 7**: Paste the copied token into GitHub Authentication and click on **‘Install’**.
+
+
+
+Go to Integrations again and you will be able to notice a green tick indicating that GitHub is successfully installed. You can now experience one-click bug logging from any of your running test sessions in to your GitHub repository directly with a single click.
+
+
+
+## Logging Your First Bug Through GitHub Integration
+***
+
+**Step 1:** Go for any of the test from the left navigation menu. For demo, we will be taking **"Real Time Test"** option.
+
+
+
+**Step 2:** Present a URL of the web-app you need to test in the dialog box. After that, select any configuration for browser and operating system of your choice & hit **‘Start’.**
+
+
+
+**Step 3**: After the VM is launched and operable. You can perform testing on your web-app for finding bugs. If a bug gets revealed, then you need to click on the **Bug icon** from the left panel for capturing a screenshot of the same.
+
+
+
+**Step 4:** After a screenshot is captured, you can annotate any issue or a task with an **in-built image editor.** Once you are done highlighting the bug, click on the button that says **"Mark as Bug".**
+
+
+
+**Step 5**: After clicking on **"Mark as Bug"** button a GitHub specific form would open up. Fill the fields as per your requirement.
+
+ - You can select which repo should the observation be marked under.
+ - You can select a relevant label for the same UI observation.
+ - You can select the Issue’s title.
+ - You also get to post a description to help relate the cause of the issue or the card.
+
+
+
+**Step 6**: Click on **"Create Issue"** & observe it being successfully marked through a single click effort. Once you hit the button, you will get prompt messages on top of your Virtual Machine indicating the progress of bug logging. You will get a prompt message in few seconds mentioning **"Bug successfully marked"** indicating that the bug has been pushed to the desired GitHub repository.
+
+
+
+**Step 7:** Visit your GitHub repository. You will be able to notice the bug logged right away under your recent activity.
+
+
+
+Click on the **description** of bug and you will be redirected to the detail page of the bug. You will find all the data that you provided through already presented in the bug. automatically includes test environment details and related screenshots in the GitHub repository as attachments.
+
+
+
+## How To Remove GitHub Integration?
+***
+
+You can work with one integration at a time. So if you would want to integrate to some 3rd party application of the similar type, other than the GitHub then you would have to remove your present integration. Here is how you can do it.
+
+**Step 1:** Login to your account.
+
+**Step 2:** Select **‘Integrations’** from the left navigation menu bar. This will guide you to the same screen from where you initiated GitHub installation. You will also find other third party applications, available to integrate with your account.
+
+**Step 3:** To remove the GitHub integration, click on **‘REMOVE’** under the category My Integrations.
+
+
+
+That was all you need to know for + GitHub 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 available on window.openLTChatWidget()}>**chat** to help you out with any roadblock regarding our product. **Happy testing!**
+
diff --git a/docs/github-repo-based-auth-integration.mdx b/docs/github-repo-based-auth-integration.mdx
new file mode 100644
index 000000000..a2572d937
--- /dev/null
+++ b/docs/github-repo-based-auth-integration.mdx
@@ -0,0 +1,58 @@
+---
+title: "Integrate TestMu AI With GitHub Using Repo-Based OAuth"
+sidebarTitle: "GitHub Repo-based OAuth"
+description: "Easily integrate TestMu AI with GitHub using repo-based OAuth to log bugs directly from the TestMu AI platform to your GitHub repositories."
+keywords: ['testmu ai github integration', 'github repo oauth testmu ai', 'testmu ai bug logging github', 'connect github to testmu ai', 'testmu ai oauth setup', 'log bugs from testmu ai to github', 'github repository integration testmu ai']
+"og:description": "Easily integrate TestMu AI with GitHub using repo-based OAuth to log bugs directly from the TestMu AI platform to your GitHub repositories."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+ allows you to integrate with GitHub using repo-based OAuth to log issues directly to your GitHub repository from the platform.
+
+## Integrating Your GitHub Account Using Repo-Based OAuth
+***
+
+1. Log in to your account. Ensure that you have either admin or user level access to view and install third-party integrations.
+
+2. Navigate to **Integrations** from the left-sidebar under **Settings**.
+
+3. Click on Project Management, then click **Connect** on the GitHub card.
+
+
+
+4. Select instance as **Repo-based OAuth**.
+
+
+
+5. Click **Install** to install the App.
+
+
+
+6. Choose the installation location. Instead of granting access to all GitHub repositories, you also have the option to select a specific repository for installing the App.
+
+After selecting the installation location, click **Request** to get the approval for the repository authorization.
+
+
+
+8. Once your installation request is approved, navigate back to the GitHub setup dashboard and click **Authorize**.
+
+
+
+9. Click **Continue** to authorize the GitHub repository.
+
+
+
+10. After you complete the authorization, GitHub will install the App.
+
+
+
+11. Navigate back to the Integrations console and you'll notice your account will be integrated with GitHub using repository-based OAuth authentication.
+
+
+
+You can now start testing your website or mobile app testing and log bugs directly from the platform to your GitHub repository.
+
+Looking to get started? Check out this documentation on [real-time testing on desktop browsers](/support/docs/getting-started-with-desktop-browser-real-time-testing/).
diff --git a/docs/github-repo-based-oauth-integration.mdx b/docs/github-repo-based-oauth-integration.mdx
new file mode 100644
index 000000000..9f0f361c4
--- /dev/null
+++ b/docs/github-repo-based-oauth-integration.mdx
@@ -0,0 +1,56 @@
+---
+title: "Github Repo Based Oauth Integration"
+sidebarTitle: "GitHub (Repo OAuth)"
+keywords: ["github", "repo", "based", "oauth", "integration"]
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+ allows you to integrate with GitHub using repo-based OAuth to log
+issues directly to your GitHub repository from the platform.
+
+## Integrating Your GitHub Account Using Repo-Based OAuth
+
+---
+
+**Step 1:** Log in to your account. Ensure that you have either admin or user level access to view and install third-party integrations.
+
+**Step 2:** Navigate to **Integrations** from the left-sidebar under **Settings**.
+
+**Step 3:** Click on **Project Management**, then click **Connect** on the GitHub card.
+
+
+
+**Step 4:** Select instance as **Repo-based OAuth**.
+
+
+
+**Step 5:** Click **Install** to install the App.
+
+
+
+**Step 6:** Choose the installation location. Instead of granting access to all GitHub repositories, you also have the option to select a specific repository for installing the App.
+
+After selecting the installation location, click **Request** to get the approval for the repository authorization.
+
+
+
+**Step 7:** Once your installation request is approved, navigate back to the GitHub setup dashboard and click **Authorize**.
+
+
+
+**Step 8:** Click **Continue** to authorize the GitHub repository.
+
+
+
+**Step 9:** After you complete the authorization, GitHub will install the App.
+
+
+
+**Step 10:** Navigate back to the Integrations console and you'll notice your account will be integrated with GitHub using repository-based OAuth authentication.
+
+
+
+You can now start testing your website or mobile app testing and log bugs directly from the platform to your GitHub repository.
+
+Looking to get started? Check out this documentation on [real-time testing on desktop browsers](/support/docs/getting-started-with-desktop-browser-real-time-testing/).
diff --git a/docs/github-with-hyperececute.mdx b/docs/github-with-hyperececute.mdx
new file mode 100644
index 000000000..412027a57
--- /dev/null
+++ b/docs/github-with-hyperececute.mdx
@@ -0,0 +1,73 @@
+---
+title: "GitHub CI Integration"
+description: "TestMu AI now integrates with GitLab 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: ['testmu ai integrations', 'testmu ai integrations with ci/cd tools', 'ci/cd tools', 'continuous integration,continuous delivery', 'continuous integration tools', 'gitlab ci']
+"og:description": "TestMu AI now integrates with GitLab 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."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+GitHub is one of the best solutions for supporting continuous integration for Git projects for clients of all sizes. Now, quickly deploy your code and extensively test it to ensure a reliable delivery for your easy release.
+
+This document will show you how to use HyperExecute Integration with GitHub Continuous Integration. We will use the WebdriverIO framework to execute our automation script.
+
+## Prerequisites For Integrating GitHub CI With HyperExecute
+To perform your WebdriverIO tests with HyperExecute, you would need the following essentials to be already set up.
+
+1. **Global Dependencies**
+
+* A Git or GitHub repository.
+* Download and install node.js and node package manager or npm.
+* To install node.js with homebrew use the command below.
+
+```
+$ brew install node
+```
+
+* If you already have npm set up, you might want to update to the most recent version. To upgrade npm, run the following code in your terminal.
+
+```
+npm install npm@latest --g
+```
+
+* Install WebdriverIO with the npm command below.
+
+```
+npm install webdriverio
+```
+
+2. ** Authentication Credentials**
+
+Keep your login, access key, and HubURL handy for authentication purposes. They must be configured as environment variables. You can find them on your automation dashboard by clicking on the key symbol next to the help button.
+
+* **For Linux/Mac**
+
+```
+$ export LT_USERNAME=YOUR_LAMBDATEST_USERNAME
+$ export LT_ACCESS_KEY=YOUR_LAMBDATEST_ACCESS_KEY
+```
+
+* **For Windows**
+
+```
+$ set LT_ACCESS_KEY=YOUR_LAMBDATEST_ACCESS_KEY
+$ set LT_ACCESS_KEY=YOUR_LAMBDATEST_ACCESS_KEY
+```
+
+## Integrating HyperExecute With GitHub CI
+* * *
+To integrate GitHub CI with HyperExecute, you need to make use of the Hyperexecute CLI. HyperExecute CLI is a command line client to interact and run tests on HyperExecute and provides a host of other useful features that accelerate test execution.
+
+For triggering tests using HyperExecute CLI, you have to download the HyperExecute CLI binary corresponding to the platform (or OS) from where the tests are triggered: Below are the HyperExecute CLI download links for different operating systems:
+
+| OS | HyperExecute CLI download link |
+| ---------| --------------------------- |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+HyperExecute CLI provides different command-line flags that let you customize the HyperExecute experience. Once you download the HyperExecute CLI in your machine, run the command *hyperexecute.exe --help* on the terminal to explore the different flags.
+
+
diff --git a/docs/github-with-hyperexecute.mdx b/docs/github-with-hyperexecute.mdx
new file mode 100644
index 000000000..87652252e
--- /dev/null
+++ b/docs/github-with-hyperexecute.mdx
@@ -0,0 +1,106 @@
+---
+title: "GitHub Actions Integration"
+sidebarTitle: "GitHub Actions"
+description: "TestMu AI now integrates with GitHub Actions Pipeline 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: ['testmu ai integrations', 'testmu ai integrations with ci/cd tools', 'ci/cd tools', 'continuous integration,continuous delivery', 'continuous integration tools', 'gitlab ci']
+"og:description": "TestMu AI now integrates with GitHub Actions Pipeline 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."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline. You can create workflows that build and test every pull request to your repository, or deploy merged pull requests to production.
+
+This document will show you how to integrate GitHub Actions Pipeline with HyperExecute to greatly shorten your test cycles.
+
+## How To Integrate GitHub Actions Pipeline with Hyperexecute
+
+***
+
+To integrate GitHub Actions Pipeline with HyperExecute, follow the below steps:
+
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+### 1. Log into your GitHub account
+- Navigate to the main page of the repository.
+- Under your repository name, click **Actions**.
+
+### 2. Create a New Workflow
+In the left sidebar, click the **New workflow** button.
+
+
+
+### 3. Create the GitHub Actions work-flow YAML file:
+
+To create the GitHub Actions pipeline YAML file, follow the sample command below:
+
+```bash
+name: HyperExecute
+on:
+ workflow_dispatch:
+ inputs:
+ username:
+ required: true
+ description: LT Username
+ accessKey:
+ description: LT Access Key
+ required: true
+
+jobs:
+ HyperExecute:
+ runs-on: ubuntu-latest
+ timeout-minutes: 15
+ strategy:
+ fail-fast: false
+ steps:
+ - name: Checkout sources
+ uses: actions/checkout@v2
+
+ - name: Download CLI and Setting Environment Variables
+ shell: bash
+ run: |
+ curl https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute -o hyperexecute
+ chmod +x hyperexecute
+
+ - name: Executing the Job
+ shell: bash
+ run: |
+ ./hyperexecute --user ${{ github.event.inputs.username }} --key ${{ github.event.inputs.accessKey }} --download-artifacts --config yaml/autosplit_linux.yaml
+ echo "Test completion"
+```
+- **On:**
+ - **Workflow_dispatch:** In the **workflow_dispatch** section, you should declare the pre-defined variables that will be used before running the GitHub Actions PipeLine as an input.
+- **Jobs:**
+ In the Jobs Section, declare the workflow of the pipeline execution.
+ - **runs-on**: Runs-on contains the value of the OS flavor you would like to execute the GitHub Actions Pipeline on.
+- **Steps**:
+In the steps section, you should declare the execution commands.
+ - The first step in the above sample YAML changes the path of the root directory.
+ - In the second step it downloads the HyperExecute CLI binary.
+ - The third step is the execution command which executes The Hyperexecute CLI binary. This contains username, access key, and path of the Yaml created for Hyperexecute. You can find more information on this [here.](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/)
+
+
+
+### 4. Run the Workflow
+To run the new pipeline that you just created, click the **Run workflow** button on the workflow page.
+
+
+
+
+**Below is an example of how a test that is run on the GitHub Actions pipeline gets executed:**
+
+
+
+
+**Below is an example of a Hyperexecute job that was triggered through the above pipeline:**
+
+
+**Run your tests at speeds never seen before. Happy testing! :)**
diff --git a/docs/gitlab-ci-integration-with-testmu.mdx b/docs/gitlab-ci-integration-with-testmu.mdx
new file mode 100644
index 000000000..fa3c9bf4f
--- /dev/null
+++ b/docs/gitlab-ci-integration-with-testmu.mdx
@@ -0,0 +1,197 @@
+---
+title: "Gitlab CI Integration"
+sidebarTitle: "Gitlab CI"
+description: "Integrate GitLab CI seamlessly with TestMu AI for efficient and automated testing, supported by step-by-step guides and detailed support doc."
+keywords:
+ [
+ "lambdatest integrations",
+ "lambdatest integrations with ci/cd tools",
+ "ci/cd tools",
+ "continuous integration,continuous delivery",
+ "continuous integration tools",
+ "gitlab ci"
+ ]
+"og:description": "Integrate GitLab CI seamlessly with TestMu AI for efficient and automated testing, supported by step-by-step guides and detailed support doc."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+* * *
+GitLab is one of the finest tools which facilitates continuous integration for Git projects from small to enterprise level clients. Now, deploy your code rapidly and test it thoroughly for a robust delivery in your go-to-market launch.
+
+ now integrates with GitLab CI to boost your go-to-market delivery. Perform automated cross browser testing with to ensure your development code renders seamlessly through an online Selenium grid providing 3000+ real browsers running through machines, on our cloud servers. Perform automation testing in parallel with ’s Selenium grid to drastically trim down your test cycles.
+
+This topic will demonstrate how you can leverage Integration with GitLab CI. We will be running our automation script using the Protractor framework.
+
+## Prerequisites For Integrating GitLab CI With Our Online Selenium Grid
+* * *
+In order to perform your protractor tests with , you would need the below things to be already set up.
+
+1. **Global Dependencies**
+
+* A Git or GitHub repository.
+* Download and install node.js and node package manager or npm.
+* To install node.js with homebrew use the command below.
+
+```
+$ brew install node
+```
+
+* If you have npm already installed, you may want to upgrade it to latest version. Here the code you can run in your terminal to upgrade npm.
+* Upgrade npm to latest version using the below command.
+
+```
+npm install npm@latest --g
+```
+
+* Install protractor using npm with the below command.
+
+```
+npm install --g protractor
+```
+
+2. ** Authentication Credential**
+
+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**
+
+```
+$ export LT_USERNAME=
+$ export LT_ACCESS_KEY=
+```
+
+* **For Windows**
+
+```
+$ set LT_ACCESS_KEY=
+$ set LT_ACCESS_KEY=
+```
+
+## Integrating With GitLab CI
+* * *
+To integrate GitLab CI with you need to make minor tweaks in the .gitlab-ci.yml which is the configuration file for your GitLab CI instance. The changes you need to make will revolve around the environment variables such as access key, username, grid config and so on.
+
+Below is a sample config file for integrating GitLab CI with . You can use the sample file to test your own automation test suite by replacing the environment variables according to your need. All the code used for the demonstration of this topic can be find in our [GitHub repository](https://github.com/LambdaTest/protractor-selenium-sample-gitlab).
+
+```
+//Sample Configuration For GitLab CI
+
+
+image: node:7.10
+
+
+before_script:
+ - |
+ cd ~/protractor-selenium-sample-gitlab
+ echo 'export LT_USERNAME="{your_lambdatest_username}"' >> ~/.bashrc
+ echo 'export LT_ACCESS_KEY="{your_lambda_access_key}"' >> ~/.bashrc
+ npm install
+ npm install -g protractor
+
+job:
+ script:
+ #Running test!
+ protractor single.conf.js
+```
+
+ offers a [Selenium Desired Capabilities Generator](https://www.lambdatest.com/capabilities-generator/) to fetch coded values for your desired test configurations. For Instance, if you select the below configurations:
+
+| FIELDS | SELECTED VALUES |
+| ------- | -------------- |
+| Operating System | Windows 8.1 |
+| Browser | Mozilla Firefox |
+| Browser Version | 62.0 |
+| Resolution | 1280×1024 |
+| Selenium Version | 3.11.0 |
+
+Then Capabilities Generator at will provide you with the below program:
+
+```
+// Basic Test Configurations For JavaScript
+
+var capabilities = {
+ "build" : "your build name", //You can edit this and assign a build name
+ "name" : "your test name", // Assign a name to your Test
+ "platform" : "Windows 8.1", // The operating system on which you want to test your website
+ "browserName" : "Firefox", // The browser on which you want to test
+ "version" : "62.0", // The browser version which you've selected to perform the test upon
+ "resolution" : "1280x1024", // The resolution in which you want to run the test as per your operating system
+ "selenium_version" : "3.11.0", //The version of Selenium on which the test will run
+ "visual" : true,
+ "firefox.driver" : v0.21.0
+}
+```
+
+
+For more information, refer to our documentation on Selenium Automation Capabilities.
+
+
+## Testing Locally Hosted or Privately Hosted Projects
+* * *
+To help you perform cross browser testing of your locally stored web pages, provides an SSH(Secure Shell) tunnel connection with the name Lambda Tunnel. With Lambda Tunnel, you can execute a test server inside your GitLab CI build a container to perform automated cross browser testing on browsers offered by Selenium grid on . So you make sure how well your changes look, even before your customers.
+Curious to know more about Lambda Tunnel?
+
+>Follow our documentation on Lambda Tunnel to know it all. OS-specific instructions to download and set up tunnel binary are at the following links.
+>
+>- [Documentation For Windows User](/support/docs/local-testing-windows/)
+>- [Documentation For Mac User](/support/docs/local-testing-macos/)
+>- [Documentation For Linux User](/support/docs/local-testing-linux/)
+
+>**Download the binary file of:**
+>
+>- [Lambda Tunnel for Windows](https://downloads.lambdatest.com/tunnel/v3/windows/64bit/LT_Windows.zip)
+>- [Lambda Tunnel for Mac](https://downloads.lambdatest.com/tunnel/v3/mac/64bit/LT_Mac.zip)
+>- [Lambda Tunnel for Linux](https://downloads.lambdatest.com/tunnel/v3/linux/64bit/LT_Linux.zip)
+
+The below example of **.gitlab-ci.yml** file would demonstrate you on how to leverage ’s Selenium grid by performing a browser test through your testing server contained in your GitLab CI build.
+
+```
+// Example of .gitlab-ci.yml for Lambda Tunnel
+
+image: node:7.10
+
+before_script:
+ - |
+ cd /builds/qarachit/protractor-selenium-sample-gitlab
+ wget https://downloads.lambdatest.com/tunnel/v3/linux/64bit/LT_Linux.zip
+ #Extracting tunnel binary
+ sudo apt-get install unzip
+ unzip LT_Linux.zip
+ #Executing tunnel library
+ ./LT -user ${LAMBDATEST_EMAIL} -key ${LAMBDATEST_KEY} &
+ sleep 30
+ #Installing Dependencies
+ echo 'export LT_USERNAME="{your_lambdatest_username}"' >> ~/.bashrc
+ echo 'export LT_ACCESS_KEY="{your_lambda_access_key}"' >> ~/.bashrc
+ npm install
+ npm install -g protractor
+
+job:
+ script:
+ #Running Test!
+ protractor single.conf.js
+```
+
+Once, the tunnel is successfully set up. You can add the below code to your capabilities for testing internal servers on your network.
+
+```
+"desiredCapabilities": {
+ "tunnel":true
+ }
+```
+
+## Parallel Testing
+* * *
+Parallel Testing is one of the most demanding features of Selenium Grid. By parallel testing, you can run more than one test case, simultaneously. This means that Parallel testing would allow you to execute numerous automation test cases altogether. So you execute a single test scenario across different browsers or could run different test scenarios across the same browser but with different browser versions.
+
+```
+protractor parallel.conf.js
+```
+
+Monitor and analyze your test result on the [ Automation Dashboard](https://automation.lambdatest.com/).
+
+Deploy your code in a reliable manner at scale using GitLab CI integration with , and ensure it looks robust across every browser to provide a seamless user experience to all your visitors. Happy Testing!
+
diff --git a/docs/gitlab-ci-integration.mdx b/docs/gitlab-ci-integration.mdx
new file mode 100644
index 000000000..6071b0369
--- /dev/null
+++ b/docs/gitlab-ci-integration.mdx
@@ -0,0 +1,187 @@
+---
+title: "GitLab CI Integration"
+sidebarTitle: "Gitlab CI"
+description: "Integrate GitLab CI seamlessly with TestMu AI for efficient and automated testing, supported by step-by-step guides and detailed support doc."
+keywords: ['testmu ai integrations', 'testmu ai integrations with ci/cd tools', 'ci/cd tools', 'continuous integration,continuous delivery', 'continuous integration tools', 'gitlab ci']
+"og:description": "Integrate GitLab CI seamlessly with TestMu AI for efficient and automated testing, supported by step-by-step guides and detailed support doc."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+GitLab is one of the finest tools which facilitates continuous integration for Git projects from small to enterprise level clients. Now, deploy your code rapidly and test it thoroughly for a robust delivery in your go-to-market launch.
+
+ now integrates with GitLab CI to boost your go-to-market delivery. Perform automated cross browser testing with to ensure your development code renders seamlessly through an online Selenium grid providing 3000+ real browsers running through machines, on our cloud servers. Perform automation testing in parallel with ’s Selenium grid to drastically trim down your test cycles.
+
+This topic will demonstrate how you can leverage Integration with GitLab CI. We will be running our automation script using the Protractor framework.
+
+## Prerequisites For Integrating GitLab CI With Our Online Selenium Grid
+* * *
+In order to perform your protractor tests with , you would need the below things to be already set up.
+
+1. **Global Dependencies**
+
+* A Git or GitHub repository.
+* Download and install node.js and node package manager or npm.
+* To install node.js with homebrew use the command below.
+
+```
+$ brew install node
+```
+
+* If you have npm already installed, you may want to upgrade it to latest version. Here the code you can run in your terminal to upgrade npm.
+* Upgrade npm to latest version using the below command.
+
+```
+npm install npm@latest --g
+```
+
+* Install protractor using npm with the below command.
+
+```
+npm install --g protractor
+```
+
+2. ** Authentication Credential**
+
+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**
+
+```
+$ export LT_USERNAME=YOUR_LAMBDATEST_USERNAME
+$ export LT_ACCESS_KEY=YOUR_LAMBDATEST_ACCESS_KEY
+```
+
+* **For Windows**
+
+```
+$ set LT_ACCESS_KEY=YOUR_LAMBDATEST_ACCESS_KEY
+$ set LT_ACCESS_KEY=YOUR_LAMBDATEST_ACCESS_KEY
+```
+
+## Integrating With GitLab CI
+* * *
+To integrate GitLab CI with you need to make minor tweaks in the .gitlab-ci.yml which is the configuration file for your GitLab CI instance. The changes you need to make will revolve around the environment variables such as access key, username, grid config and so on.
+
+Below is a sample config file for integrating GitLab CI with . You can use the sample file to test your own automation test suite by replacing the environment variables according to your need. All the code used for the demonstration of this topic can be find in our [GitHub repository](https://github.com/LambdaTest/protractor-selenium-sample-gitlab).
+
+```
+//Sample Configuration For GitLab CI
+
+# Choose language and version
+image: node:7.10
+
+# setup required installers
+before_script:
+ - |
+ cd ~/protractor-selenium-sample-gitlab
+ echo 'export LT_USERNAME="{your_lambdatest_username}"' >> ~/.bashrc
+ echo 'export LT_ACCESS_KEY="{your_lambda_access_key}"' >> ~/.bashrc
+ npm install
+ npm install -g protractor
+
+job:
+ script:
+ #Running test!
+ protractor single.conf.js
+```
+
+ offers a [Selenium Desired Capabilities Generator](https://www.testmuai.com/capabilities-generator/) to fetch coded values for your desired test configurations. For Instance, if you select the below configurations:
+
+| FIELDS | SELECTED VALUES |
+| ------- | -------------- |
+| Operating System | Windows 8.1 |
+| Browser | Mozilla Firefox |
+| Browser Version | 62.0 |
+| Resolution | 1280×1024 |
+| Selenium Version | 3.11.0 |
+
+Then Capabilities Generator at will provide you with the below program:
+
+```
+// Basic Test Configurations For JavaScript
+
+var capabilities = {
+ "build" : "your build name", //You can edit this and assign a build name
+ "name" : "your test name", // Assign a name to your Test
+ "platform" : "Windows 8.1", // The operating system on which you want to test your website
+ "browserName" : "Firefox", // The browser on which you want to test
+ "version" : "62.0", // The browser version which you've selected to perform the test upon
+ "resolution" : "1280x1024", // The resolution in which you want to run the test as per your operating system
+ "selenium_version" : "3.11.0", //The version of Selenium on which the test will run
+ "visual" : true,
+ "firefox.driver" : v0.21.0
+}
+```
+
+
+For more information, refer to our documentation on Selenium Automation Capabilities.
+
+
+## Testing Locally Hosted or Privately Hosted Projects
+* * *
+To help you perform cross browser testing of your locally stored web pages, provides an SSH(Secure Shell) tunnel connection with the name Lambda Tunnel. With Lambda Tunnel, you can execute a test server inside your GitLab CI build a container to perform automated cross browser testing on browsers offered by Selenium grid on . So you make sure how well your changes look, even before your customers.
+Curious to know more about Lambda Tunnel?
+
+>Follow our documentation on Lambda Tunnel to know it all. OS-specific instructions to download and set up tunnel binary are at the following links.
+>
+>- [Documentation For Windows User](/support/docs/local-testing-for-windows/)
+>- [Documentation For Mac User](/support/docs/local-testing-for-macos/)
+>- [Documentation For Linux User](/support/docs/local-testing-for-linux/)
+
+>**Download the binary file of:**
+>
+>- [Lambda Tunnel for Windows](https://downloads.lambdatest.com/tunnel/v3/windows/64bit/LT_Windows.zip)
+>- [Lambda Tunnel for Mac](https://downloads.lambdatest.com/tunnel/v3/mac/64bit/LT_Mac.zip)
+>- [Lambda Tunnel for Linux](https://downloads.lambdatest.com/tunnel/v3/linux/64bit/LT_Linux.zip)
+
+The below example of **.gitlab-ci.yml** file would demonstrate you on how to leverage ’s Selenium grid by performing a browser test through your testing server contained in your GitLab CI build.
+
+```
+// Example of .gitlab-ci.yml for Lambda Tunnel
+
+image: node:7.10
+
+before_script:
+ - |
+ cd /builds/qarachit/protractor-selenium-sample-gitlab
+ wget https://downloads.lambdatest.com/tunnel/v3/linux/64bit/LT_Linux.zip
+ #Extracting tunnel binary
+ sudo apt-get install unzip
+ unzip LT_Linux.zip
+ #Executing tunnel library
+ ./LT -user ${LAMBDATEST_EMAIL} -key ${LAMBDATEST_KEY} &
+ sleep 30
+ #Installing Dependencies
+ echo 'export LT_USERNAME="{your_lambdatest_username}"' >> ~/.bashrc
+ echo 'export LT_ACCESS_KEY="{your_lambda_access_key}"' >> ~/.bashrc
+ npm install
+ npm install -g protractor
+
+job:
+ script:
+ #Running Test!
+ protractor single.conf.js
+```
+
+Once, the tunnel is successfully set up. You can add the below code to your capabilities for testing internal servers on your network.
+
+```
+"desiredCapabilities": {
+ "tunnel":true
+ }
+```
+
+## Parallel Testing
+* * *
+Parallel Testing is one of the most demanding features of Selenium Grid. By parallel testing, you can run more than one test case, simultaneously. This means that Parallel testing would allow you to execute numerous automation test cases altogether. So you execute a single test scenario across different browsers or could run different test scenarios across the same browser but with different browser versions.
+
+```
+protractor parallel.conf.js
+```
+
+Monitor and analyze your test result on the [ Automation Dashboard](https://automation.lambdatest.com/).
+
+Deploy your code in a reliable manner at scale using GitLab CI integration with , and ensure it looks robust across every browser to provide a seamless user experience to all your visitors. Happy Testing!
diff --git a/docs/gitlab-integration-with-hyperexecute.mdx b/docs/gitlab-integration-with-hyperexecute.mdx
new file mode 100644
index 000000000..66109a254
--- /dev/null
+++ b/docs/gitlab-integration-with-hyperexecute.mdx
@@ -0,0 +1,103 @@
+---
+title: "GitLab Integration:HyperExecute"
+sidebarTitle: "Run on GitLab"
+description: "TestMu AI integrates with GitLab Pipeline 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: ['testmu ai integrations', 'testmu ai integrations with ci/cd tools', 'ci/cd tools', 'continuous integration,continuous delivery', 'continuous integration tools', 'gitlab ci']
+"og:description": "TestMu AI integrates with GitLab Pipeline 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."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+
+GitLab is a web-based Git repository that provides free open and private repositories, issue-following capabilities, and wikis. It is a complete DevOps platform that enables professionals to perform all the tasks in a project—from project planning and source code management to monitoring and security.
+
+This document will show you how to integrate GitLab Pipeline with HyperExecute to greatly shorten your test cycles.
+
+## How To Integrate GitLab Pipeline with Hyperexecute
+
+***
+
+To integrate GitLab Pipeline with HyperExecute, follow the below steps:
+
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+### 1. Log into your GitLab account
+
+### 2. Create a New Project
+
+To create a new project and connect your external repository to GitLab CI/CD, click the **Run CI/CD for external repository** tab on the bottom right.
+
+
+
+### 3. Connect Your External Repository:
+
+On GitLab, you can either connect your external repository from [GitHub](https://www.github.com) or by URL. In this example, we will connect our external repository by URL.
+
+To connect your external repository by URL, fill in the required information in the form below and click the **Create Project** button at the bottom of the page.
+
+
+
+### 4. Configure the Pipeline
+- To configure the new pipeline that you just created, click the **Configure Pipeline** button in the center of the page.
+
+
+
+
+- Click on the **+Set up CI/CD** button as shown below.
+
+
+
+- Create a new `.gitlab-ci.yml` file at the root of the repository.
+
+Below is a sample of GitLab YAML created for your reference:
+
+```bash
+## Define the image to use (adjust for macOS if needed)
+image: ubuntu:latest
+
+## Define pipelines (can have multiple pipelines)
+pipelines:
+ ## Default pipeline (can be named differently)
+ default:
+ ## Branches to trigger this pipeline on (adjust as needed)
+ branches:
+ - master
+
+ ## Define steps in the pipeline
+ steps:
+ ## Download Hyperexecute CLI (descriptive name)
+ - name: Download Hyperexecute CLI
+ script: |
+ wget https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute
+ chmod u+x hyperexecute
+
+ ## Run Hyperexecute tests (descriptive name)
+ - name: Run Hyperexecute Tests
+ script: |
+ ./hyperexecute --user --key --config
+```
+
+### 5. Run Your Job
+- To commit your changes and run your job, click the **Commit Changes** button.
+
+
+
+
+
+**Below is an example of a Hyperexecute job that was triggered through the above pipeline:**
+
+
+**Run your tests at speeds never seen before. Happy testing! :)**
diff --git a/docs/gitlab-integration.mdx b/docs/gitlab-integration.mdx
new file mode 100644
index 000000000..9c5466285
--- /dev/null
+++ b/docs/gitlab-integration.mdx
@@ -0,0 +1,168 @@
+---
+title: "GitLab Integration"
+sidebarTitle: "GitLab"
+keywords:
+ [
+ "testmu ai integrations",
+ "push issues to gitlab",
+ "free cross browser testing tool",
+ ]
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+***
+
+GitLab is a web-based Git-repository manager with the purpose of facilitating entire DevOps lifecycle. It helps in the collaboration of different teams working on a project. Ensuring Development, QA, Security, Operations and Product team to sync simultaneously on the same project. GitLab helps in bringing your product a lot faster in the market by reducing the time taken to complete a release cycle in a very significant manner.
+
+
+The GitLab Integration allows you to create a card directly in your repository from platform. Push an issue to your respective repository anytime, even in the middle of your test session. The fields populated by you when marking as a bug through are displayed as information on the bug in GitLab repository for that testing instance.
+
+**GitLab Integration with , like all of our other integrations to 3rd party applications, is available for freemium as well as premium plan.**
+
+## How To Integrate GitLab With Your Account?
+***
+**Step 1:** Login to your account. You would need to have Admin or User level access to see and install integrations.
+
+**Step 2:** Select **‘Integrations’** 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:** Here under the ‘Project Management’ Section, you’ll find GitLab. Click on Gitlab block.
+
+
+
+**Step 4:** Once you click on install, you’ll be redirected to a screen. There would 2 options available for you to choose in order to **authenticate GitLab.**
+
+### 1. Via OAuth
+***
+1. Select the radio button on **‘Via OAuth’** and hit **‘Next’.**
+
+
+
+2. You will be redirected to GitLab login page where you will be asked to provide your login credentials.
+
+
+
+3. If you are new to GitLab and want to sign up then you can do so with your GitHub account as well. Once you click on the **‘GitHub’** button you will be redirected to an authorization page. There you will authorize GitLab APIs to fetch your user owned resources from GitHub APIs.
+
+
+
+4. After you login, you will have to authorize to use your account. Click on the green button that says **‘Authorize’.**
+
+
+
+---
+
+* **Why do you need to login?**
+
+The purpose of logging in is to bypass the authentication that is applied when two different applications interact using their respective APIs. GitLab APIs uses OAuth 2.0’s [authorization code grant flow](https://tools.ietf.org/html/rfc6749#section-4.1) for generating access tokens on user’s behalf.
+
+* **What is an Access token?**
+
+Access tokens are strings with authorization key required to access an API. They are issued to the client server and are usually opaque. They are used for requesting access to protected, user-specific resources. Access tokens are vital from a security point of view & can be generated in different formats, depending upon security requirements specified on the resource server.
+
+---
+
+That’s it! Go to Integrations again and you will be able to notice a **green tick** indicating that GitLab is successfully **installed**. You can now experience bug logging in a fly from any of your running test session in to your repository directly by a single click.
+
+**Note:** Make sure you already have a project in your Gitlab account before you integrate to avoid any issues
+
+### 2. Using Personal Access Token
+***
+1. Select the radio button on **‘Cloud’** and click **‘Install’**. Here you’ll need to enter your Gitlab API token to validate integration with .
+
+
+
+2. Login to your Gitlab account. Go to the profile icon on the top-right corner and click on ‘Settings’.
+
+
+
+3. Click the ‘Access Tokens’ from the menu on the left.
+
+
+
+4. **"Add a personal access token"** by providing a name for the application. Keep the name that is easy for you to remember as you access token will be derived from it. You can also set an expiry date for that token. Also, select the checkboxes for **‘api’, ‘read_user’ & read_repository** as scopes. These scopes will define the access to authenticate API over Basic OAuth for their respective personal token. After selecting the scopes hit the green button to **"Create personal access token".**
+
+
+
+---
+* **What is a Personal Access Token?**
+
+In scenarios where OAuth is excessively utilized, Personal Access Tokens comes to aid in accessing the API. While generating a token, make sure you provide a description that is easy to remember, as your Personal Access Token will be derived from it. Treat this token just as you would treat your own password! Access tokens are strings with authorization key required to access an API. They are issued to the client server and are usually opaque. They are used for requesting access to protected, user-specific resources. Access tokens are vital from a security point of view & can be generated in different formats, depending upon security requirements specified on the resource server.
+
+---
+
+After you click on **"Create personal access token",** you will get a prompt message saying **"Your new personal access token has been created".** You will find it under the highlighted field.
+
+
+
+Your **API token** is now ready. Copy the token & store it safely with you, as you will not be able to find it again. Paste the copied token into GitLab Authentication.
+
+
+
+That’s it! Go to Integrations again and you will be able to notice a **green tick** indicating that GitLab is successfully installed. You can now experience bug logging in a fly from any of your running test session in to your repository directly by a single click.
+
+
+
+## Logging Your First Bug Through GitLab Integration?
+***
+---
+
+**NOTE:** You need to have a project created on Gitlab before you perform one click bug logging through . If a project is not created then you will face the below error message when logging a bug.
+
+
+
+---
+
+**Step 1:** Go for any of the test from the left navigation menu. For demo, we will be taking **"Real Time Test"** option.
+
+**Step 2:** Present a URL of the web-app you need to test in the dialog box. After that, select any configuration for browser and operating system of your choice & click **‘Start‘.**
+
+
+
+**Step 3:** After the VM is launched and operable. You can perform testing on your web-app for finding bugs. If a bug gets revealed, then you need to click on the **Mark as Bug** from the left panel for [capturing a screenshot](https://www.lambdatest.com/full-page-screen-capture) of the same. We have highlighted that option with yellow in the below image.
+
+
+
+**Step 4:** After a screenshot is captured, you can annotate any issue or a task with an in-built image editor. Once you are done highlighting the bug, click on the button that says **"Mark as Bug".**
+
+
+
+**Step 5:** After clicking on **"Mark as Bug"** button a GitLab specific form would open up. Fill the fields as per your requirement.
+
+ - You can select which **Projects** should the observation be marked under.
+ - You can select a relevant **Label** for the same UI observation.
+ - You can give a title to the bug through the field **Title.**
+ - You also get to post a **Description** to help relate the cause of the issue or the card.
+
+
+
+**Step 6:** Click on **"Create Bug"** & observe it being successfully marked through a single click effort. Once you hit the button, you will get **prompt messages** on top of your Virtual Machine indicating the progress of bug logging. You will get a prompt message in few seconds mentioning **"Bug marked successfully"** indicating that the bug has been pushed to the desired GitLab repository.
+
+
+
+**Step 7:** Visit the project you marked your bugs to. You will notice that the number of issues has increased!
+
+
+
+**Step 8.** Click on **‘Issues’,** in the next scene, you’ll find your bug along with the list of all the issues logged in the project.
+
+
+
+**Step 9.** Click on the description of bug and you will be redirected to the detail page of the bug. You will find all the data that you provided through already presented in the bug. automatically includes test environment details and related screenshots in the repository as attachments.
+
+
+
+## How To Uninstall GitLab Integration?
+***
+You can work with one integration at a time. So if you would want to integrate to some 3rd party application of the similar type, other than the GitLab then you would have to uninstall your present integration. Here is how you can do it.
+
+**Step 1:** Login to your account.
+
+**Step 2:** Select **‘Settings’** from the left navigation menu bar & click on **‘Integrations’.** This will guide you to the same screen from where you initiated **GitLab installation.** You will find Gitlab in the ‘My Integrations’ section.
+
+**Step 3:** To remove the GitLab integration, click on **‘Remove’.** You can find the **Remove** button right next to **GitLab** icon
+
+
+
+That was all you need to know for + GitLab 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!
+
diff --git a/docs/gocd-integration-with-hyperexecute.mdx b/docs/gocd-integration-with-hyperexecute.mdx
new file mode 100644
index 000000000..ece957aca
--- /dev/null
+++ b/docs/gocd-integration-with-hyperexecute.mdx
@@ -0,0 +1,146 @@
+---
+title: "How to integrate GoCD With HyperExecute"
+sidebarTitle: "Run on GoCD"
+description: "HyperExecute integration with GoCD will help your perform Test automation for your code changes on more than 3000+ real browsers for both mobile and desktop. You can trigger your testing scripts directly from GoCD instance and they would be executed over your HyperExecute Dashboard."
+keywords: ['gocd', 'testmu ai', 'gocd integrations', 'gocd pipelines', 'gocd testmu ai', 'gocd integration with hyperexecute', 'hyperexecute integration with gocd pipelines', 'ci/cd']
+"og:description": "HyperExecute integration with GoCD will help your perform Test automation for your code changes on more than 3000+ real browsers for both mobile and desktop. You can trigger your testing scripts directly from GoCD instance and they would be executed over your HyperExecute Dashboard."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+GoCD, short for "Go Continuous Delivery," is an open-source continuous integration and continuous delivery (CI/CD) server that helps automate and streamline the software development and release process. It is designed to facilitate the efficient and reliable delivery of software from development to production.
+
+This document will show you how to integrate GoCD with HyperExecute to greatly shorten your test cycles.
+
+## How to Integrate with HyperExecute
+
+### Pre-requisite:
+
+- [Download](https://www.gocd.org/download/#osx) the GoCD Server and Agent and unzip the folder.
+
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+### Step 1: Start the GoCD Server
+
+- Go to the gocd/bin folder and run the following commands:
+
+ - To start the Server
+ ```bash
+ ./bin/go-server start
+ ```
+
+ - To start the Agent
+ ```bash
+ ./bin/go-agent start
+ ```
+- Now type ``http://localhost:8153/`` go in your browser to open the GoCD GUI.
+
+- Click on the New Pipeline Button.
+
+
+
+### Step 2: Configure the GoCD Pipeline
+
+#### Part 1: Material
+
+- Select the **Material Type**. For the demo purposes, we will be using the Git.
+
+- Enter the **Repository URL** from which you want to set up the project.
+
+- Enter your **Repository branch** name.
+
+- Enter the **Username** and **Password** of your GitHub. (It is required in case the access to the repo needed authentication).
+
+
+
+#### Part 2: Pipeline Name
+
+- Enter your **Pipeline Name**.
+
+#### Part 3: Stage Details
+
+A Stage is a group of Jobs and a Job is a work which needs to be executed.
+
+- Enter your **Stage Details**.
+
+
+
+#### Part 4: Job and Tasks
+
+- Enter the **Job Name**.
+
+- Enter the below mentioned script in the space provided.
+
+```bash
+curl -O https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute
+chmod +x hyperexecute
+./hyperexecute --user --key --config
+```
+
+
+Since my default agent is mac I am using darwin CLI in the cURL command. Kindly change it according to your system default agent.
+
+- **Mac** -> darwin
+- **Linux** -> linux
+- **Windows**-> windows
+
+- Click on **Save + Run This Pipeline** button.
+
+
+
+### Job Running
+
+Now the Job is executed and running. You can check the status of Job in the:
+
+- #### GoCD GUI
+
+
+- #### GoCD Console
+
+
+- #### HyperExecute Dashboard
+
+After the build is successful, go to your HyperExecute Dashboard and check the output of the triggered Job.
+
+
+
+- #### Job Status Passed
+
+
+
+## Sample Workflow File
+
+```xml
+
+
+
+ # Adjust for macOS if needed
+
+
+
+
+
+
+
+
+ # Adjust for macOS if needed
+
+
+
+
+
+
+```
diff --git a/docs/gocd-integration-with-testmu.mdx b/docs/gocd-integration-with-testmu.mdx
new file mode 100644
index 000000000..9f09f163f
--- /dev/null
+++ b/docs/gocd-integration-with-testmu.mdx
@@ -0,0 +1,78 @@
+---
+title: "GoCD Integration With TestMu AI"
+sidebarTitle: "GoCD"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+***
+
+GoCD offers a free and open-source platform to help you configure robust CI/CD pipelines with ease. The intuitive UI offers an end-to-end view wherein you can visualize the entire migration path to production in a collective view. That way, you can easily pinpoint the inefficient areas to optimize the CI/CD process. By leveraging GoCD, you can achieve faster feedback loops through its modelling constructs which makes your complex CI/CD pipeline looks a lot simpler. You also get features like dependency management & parallel execution to help you deliver better products quicker.
+
+ integration with GoCD will help your perform Selenium test automation for your code changes on more than 3000+ real browsers for both mobile and desktop. You can trigger your Selenium testing scripts directly from GoCD instance and they would be executed over your automation dashboard.
+
+## Prerequisites
+***
+
+1. Copy the YAML configuration file from our [GitHub repository for GoCD](https://github.com/LambdaTest/nightwatch-gocd-sample/blob/master/nightwatch-gocd-sample.gocd.yaml).
+
+2. ** 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](https://automation.lambdatest.com/) by clicking on the key icon near the help button.
+
+ * **For Linux/Mac:**
+
+ ---
+ $ export LT_USERNAME= `{YOUR_LAMBDATEST_USERNAME}`
+
+ $ export LT_ACCESS_KEY= `{YOUR_LAMBDATEST_ACCESS_KEY}`
+
+ ---
+
+ * **For Windows:**
+
+ ---
+ $ set LT_USERNAME= `{YOUR_LAMBDATEST_USERNAME}`
+
+ $ set LT_ACCESS_KEY= `{YOUR_LAMBDATEST_ACCESS_KEY}`
+
+ ---
+
+3. Make sure to install GoCD in your system.
+
+## Configuring GoCD Pipeline For Selenium Grid
+***
+
+**Step 1:** Visit your GoCD Dashboard and create a new pipeline by selecting the option to "Use Pipeline as Code".
+
+
+
+**Step 2:** Scroll-down to the section to "Register Your Pipelines as Code Repo with GoCD" and untick the box for using the same SCM repository.
+
+
+
+**Step 3:** Provide the [ GitHub repository for GoCD](https://github.com/LambdaTest/nightwatch-gocd-sample) as the repository URL. Test you connection and provide a label for this repository. In our case, we have provided the label as Sample-Pipeline, you may keep something else for your instance.
+
+
+
+**Step 4:** After providing the GitHub repository, you will need to Scan it. Hit the highlighted button to Scan repository and you will notice that a respective YAML definition file would be through the repository.
+
+
+
+**Step 5:** After scanning the repository, you need to scroll to bottom and hit finish. Make sure to specify the username and password under the advanced setting, for private repositories.
+
+
+
+**Step 6:** Once you hit the finish button. Under the Config repositories, you will find the details of the repository as specified by you.
+
+
+
+**Step 7:** Now, if you visit your GoCD dashboard, you will find the pipeline generated and the job in running state.
+
+
+
+**Step 8:** If you open the pipeline and refer to the console then you will notice the current job status as passed.
+
+
+
+Great work! You have successfully integrated your GoCD instance with your account. Follow our another documentation, if you wish to configure a private YAML and then integrate your GoCD pipeline with .
+
diff --git a/docs/gocd-integration.mdx b/docs/gocd-integration.mdx
new file mode 100644
index 000000000..5727b4823
--- /dev/null
+++ b/docs/gocd-integration.mdx
@@ -0,0 +1,80 @@
+---
+title: "How to integrate GoCD With TestMu AI"
+sidebarTitle: "GoCD"
+description: "TestMu AI integration with GoCD will help your perform Selenium test automation for your code changes on more than 3000+ real browsers for both mobile and desktop. You can trigger your Selenium testing scripts directly from GoCD instance and they would be executed over your TestMu AI automation dashboard."
+keywords: ['gocd', 'testmu ai', 'gocd integrations', 'gocd pipelines', 'gocd testmu ai', 'gocd integration with testmu ai', 'testmu ai integration with gocd pipelines', 'ci/cd']
+"og:description": "TestMu AI integration with GoCD will help your perform Selenium test automation for your code changes on more than 3000+ real browsers for both mobile and desktop. You can trigger your Selenium testing scripts directly from GoCD instance and they would be executed over your TestMu AI automation dashboard."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+GoCD offers a free and open-source platform to help you configure robust CI/CD pipelines with ease. The intuitive UI offers an end-to-end view wherein you can visualize the entire migration path to production in a collective view. That way, you can easily pinpoint the inefficient areas to optimize the CI/CD process. By leveraging GoCD, you can achieve faster feedback loops through its modelling constructs which makes your complex CI/CD pipeline looks a lot simpler. You also get features like dependency management & parallel execution to help you deliver better products quicker.
+
+ integration with GoCD will help your perform Selenium test automation for your code changes on more than 3000+ real browsers for both mobile and desktop. You can trigger your Selenium testing scripts directly from GoCD instance and they would be executed over your automation dashboard.
+
+## Prerequisites
+***
+
+1. Copy the YAML configuration file from our [GitHub repository for GoCD](https://github.com/LambdaTest/nightwatch-gocd-sample/blob/master/nightwatch-gocd-sample.gocd.yaml).
+
+2. ** 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](https://automation.lambdatest.com/) by clicking on the key icon near the help button.
+
+ * **For Linux/Mac:**
+
+ ---
+ $ export LT_USERNAME= `YOUR_LAMBDATEST_USERNAME`
+
+ $ export LT_ACCESS_KEY= `YOUR_LAMBDATEST_ACCESS_KEY`
+
+ ---
+
+ * **For Windows:**
+
+ ---
+ $ set LT_USERNAME= `YOUR_LAMBDATEST_USERNAME`
+
+ $ set LT_ACCESS_KEY= `YOUR_LAMBDATEST_ACCESS_KEY`
+
+ ---
+
+3. Make sure to install GoCD in your system.
+
+## Configuring GoCD Pipeline For Selenium Grid
+***
+
+**Step 1:** Visit your GoCD Dashboard and create a new pipeline by selecting the option to "Use Pipeline as Code".
+
+
+
+**Step 2:** Scroll-down to the section to "Register Your Pipelines as Code Repo with GoCD" and untick the box for using the same SCM repository.
+
+
+
+**Step 3:** Provide the [ GitHub repository for GoCD](https://github.com/LambdaTest/nightwatch-gocd-sample) as the repository URL. Test you connection and provide a label for this repository. In our case, we have provided the label as Sample-Pipeline, you may keep something else for your instance.
+
+
+
+**Step 4:** After providing the GitHub repository, you will need to Scan it. Hit the highlighted button to Scan repository and you will notice that a respective YAML definition file would be through the repository.
+
+
+
+**Step 5:** After scanning the repository, you need to scroll to bottom and hit finish. Make sure to specify the username and password under the advanced setting, for private repositories.
+
+
+
+**Step 6:** Once you hit the finish button. Under the Config repositories, you will find the details of the repository as specified by you.
+
+
+
+**Step 7:** Now, if you visit your GoCD dashboard, you will find the pipeline generated and the job in running state.
+
+
+
+**Step 8:** If you open the pipeline and refer to the console then you will notice the current job status as passed.
+
+
+
+Great work! You have successfully integrated your GoCD instance with your account. Follow our another documentation, if you wish to configure a private YAML and then integrate your GoCD pipeline with .
diff --git a/docs/goodday-integration.mdx b/docs/goodday-integration.mdx
new file mode 100644
index 000000000..cd6d935d7
--- /dev/null
+++ b/docs/goodday-integration.mdx
@@ -0,0 +1,122 @@
+---
+title: "GoodDay Integration"
+sidebarTitle: "GoodDay"
+description: "TestMu AI helps you manage your bugs in GoodDay by moving them to project in a single click. All the details you provide in TestMu AI like task list, assignee, title and description would automatically be presented in the project on GoodDay."
+keywords: ['testmu ai integrations', 'push issues to GoodDay', 'free cross browser testing tool', 'cross platform testing tools', 'check browser compatibility online', 'testmu ai GoodDay integration', 'integrate GoodDay with testmu ai', 'create issue in GoodDay from testmu ai', 'GoodDay integration with testmu ai', 'create GoodDay issues from testmu ai', 'bug tracking tools', 'project management tools']
+"og:description": "TestMu AI helps you manage your bugs in GoodDay by moving them to project in a single click. All the details you provide in TestMu AI like task list, assignee, title and description would automatically be presented in the project on GoodDay."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+GoodDay is a comprehensive work management platform that offers tools for project management, task organization, and productivity growth with features that boost transparency, agility, and motivation. With GoodDay as the bug tracking tool, project teams can easily avoid the hassle of digging through bug logs for hours. Bugs are a part of the software development process, which is unlikely to change. As software projects grow in features, their complexity also increases, which increases the number of bugs. The GoodDay bug tracker lets users capture, log, and prioritize the bugs that require fixing on priority. GoodDay integrates with the tools you use daily, letting you work faster and deliver more quality software on time. The GoodDay bug tracker template has a Kanban board to represent all the relevant information about each bug. It shows who is responsible for fixing the bug and when, so you can assign the bug to the person responsible. You can even set a deadline or schedule the task to have all the bugs resolved.
+
+
+
+The GoodDay integration helps you in filing bug-related issues to your project in GoodDay directly from the platform. With one-click integration, you can push annotated bug issues to the project of your choice, assign them to the required teammate, and attach necessary screenshots. You can do all that while in the middle of a test session in the platform. The fields populated by you when marking as a bug through are displayed as information on the GoodDay platform for a testing instance.
+
+
+GoodDay Integration with , like all of the integrations to 3rd party applications, is available for freemium as well as premium plans.
+
+
+## How To Establish Integration With GoodDay From Your Account?
+***
+**Step 1:** Log in to your account. You would need to have Admin or User level access to see and install integrations.
+
+**Step 2:** Select ‘Integrations’ 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 ‘GoodDay’.
+
+
+
+**Step 4:** Once you click on Add icon, you will be redirected to the below screen. You will be asked to provide your GoodDay API Token credentials in the highlighted fields to establish integration with .
+
+
+
+
+**What is an API token?**
+
+What is an API token? 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.
+
+**Step 5:** You can find your API token from your GoodDay account. If you have not generated one before, you can generate an API token by going to the settings. You will find the "Settings" icon on the top right corner of your dashboard.
+
+
+
+**Step 6:** As you click on "Settings", you will see a section named "Integrations" on the left side navigation bar. Upon clicking "Integrations", you need to select "API" from the drop-down.
+
+
+
+**Step 7:** Now click on the button "Generate" in order to generate your API token.
+
+
+
+
+You can keep a note of this API token with you for future authentication. Although, in case you forget to do so, or you end up neglecting it due to some reason. Then there is no need to panic! You can create a new token by defining a new label. You can also delete a previously declared API Key, in case you feel that your API Key has been placed in some wrong hands. You can delete an API Key by hovering over the label and clicking on the bin icon.
+
+
+**Step 8:** Copy the newly generated API token.
+
+
+
+**Step 9:** Paste the API token into the field provided at & hit the ‘Install’ button. You are all set to experience one-click bug logging to share your issues directly from your account to your project on GoodDay.
+
+
+
+That’s it! Go to Integrations again and you will be able to notice a green tick indicating that GoodDay is successfully installed.
+
+
+
+## How To Log Your First Bug Through GoodDay Integration?
+***
+**Step 1:** Go for any of the test from the left navigation menu. For demo, we will be taking "Real Time Test" option.
+
+**Step 2:** Present a URL of the web-app you need to test in the dialog box. After that, select any configuration for browser and operating system of your choice & hit ‘Start‘.
+
+
+
+**Step 3:** After the VM is launched and operable. You can perform testing on your web-app for finding bugs. If a bug gets revealed, then you need to click on the Bug icon from the left panel for capturing a screenshot of the same.
+
+
+
+**Step 4:** After a screenshot is captured, you can annotate any issue or a task with an in-built image editor. Once you are done highlighting the bug, click on the button that says "Mark as Bug".
+
+
+
+**Step 5:** After clicking on "Mark as Bug" button a GoodDay specific form would open up. Fill the fields as per your requirement. Click on "Create Issue" & observe it being successfully marked through a single click effort. You can select the following:
+
+* You can select which **Project** should the ticket go under.
+* You can set the particular **Story Type**.
+* You can assign the bug to a colleague by populating the **Assignee** field.
+* You can mention the **Summary** as well to easily organize your bugs.
+* You also get to post a **Description** to help relate the cause of the issue or the task.
+
+
+
+**Step 6:** Visit your GoodDay dashboard. Under "Pinned Projects", you will find the recently raised issue being highlighted.
+
+
+
+**Step 8:** As you click on the recently raised issue under the "Not Started" tab, you will notice that all the data which you provided through would already be presented in it. automatically includes test environment details and related screenshots in the ticket as attachments.
+
+
+
+## How To Uninstall GoodDay Integration?
+
+***
+
+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 `uninstall` your current integration. Here is how you can do that.
+
+
+**Step 1:** Login to your account.
+
+**Step 2:** Select ‘Integration’ from the left navigation menu bar. 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 ‘GoodDay’ block which would be highlighted with a green tick.
+
+
+
+
+That was all you need to know for + GoodDay 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!
+
diff --git a/docs/google-chat-integration.mdx b/docs/google-chat-integration.mdx
new file mode 100644
index 000000000..b2f8482b4
--- /dev/null
+++ b/docs/google-chat-integration.mdx
@@ -0,0 +1,103 @@
+---
+title: "Google Chat Integration"
+sidebarTitle: "Google Chat"
+description: "TestMu AI helps you manage your bugs in Google Chat by moving them to project in a single click. All the details you provide in TestMu AI like task list, assignee, title and description would automatically be presented in the project in your Google Chat Space."
+keywords: ['testmu ai integrations', 'push issues to Google Chat', 'free cross browser testing tool', 'cross platform testing tools', 'check browser compatibility online', 'testmu ai Google Chat integration', 'integrate Google Chat with testmu ai', 'create issue in Google Chat from testmu ai', 'Google Chat integration with testmu ai', 'create Google Chat issues from testmu ai', 'bug tracking tools', 'project management tools']
+"og:description": "TestMu AI helps you manage your bugs in Google Chat by moving them to project in a single click. All the details you provide in TestMu AI like task list, assignee, title and description would automatically be presented in the project in your Google Chat Space."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Google Chat enables business teams to streamline their communications within Google Workspace. With Google Chat, you can chat using text, create collaborative chat rooms, share files, and hold virtual conferences.
+
+ and Google Chat can be used to create test cards in Google Chats Spaces for logged bugs in . This will notify you every time a new bug is pushed while performing [cross browser testing](https://www.lambdatest.com/) of websites.
+
+## Integrating Google Chat With
+***
+**Step 1:** Sign in to your Google account and head to **Google Chat**.
+
+**Step 2:** Create or select a **Google Space** from the left panel. If you don’t have a Google Space, you can create one by clicking the **"+"** icon.
+
+
+
+**Step 3:** Click on **Create a new space**.
+
+
+
+**Step 4:** Enter your preferred **Space Name** and click **Create**.
+
+
+
+**Step 5:** Now you have a new **Google Space** created.
+
+
+
+**Step 6:** Head to the **Integrations** in your Dashboard. Add **Google Chat** from under the Communication section.
+
+
+
+**Step 7:** Click on the **Sign in with Google** button.
+
+
+
+**Step 8:** Select the **Google account** that you have used to create your Google Space.
+
+
+
+**Step 9:** Click on **Allow** to let access your Google Account to complete the integration.
+
+
+
+**Step 10:** Now select your Google Space from the dropdown and click **Install**.
+
+
+
+**Step 11:** You can now see in your **Google Chat Dashboard** that we have successfully integrated with Google Chat.
+
+
+
+## One-Click Bug Logging With Google Chat
+***
+To demonstrate, we take an example of Real-time testing.
+
+**Step 1:** Select Real-Time Testing from the left menu.
+
+**Step 2:** Provide your test URL, and select the configurations: Browser, Browser versions, OS, and Resolution. Click on **Start**.
+
+
+
+**Step 3:** A virtual machine will launch where you can perform real-time testing of websites and web apps. If you identify a bug, click on the **'Mark as Bug'** icon from the left bar to capture the screenshot.
+
+
+
+**Step 4:** Once the screenshot is captured, annotate issues or tasks you have encountered using in-built image editor tools. After annotating the bugs, click on the **bug** icon in the right-side panel.
+
+
+
+**Step 5:** A Google Chat ticket will open up. Fill in the details like **Assignee, Issue Type, Priority, Summary, and Description**. After populating the required fields, check the **"Send to Google Chat"** option and click **'Mark as Bug'**.
+
+
+
+**Step 6:** To view your logged bugs, head to the **Issue Tracker** under the **Manage** section on the left navigation menu. You'll notice the marked bugs along with the Test details.
+
+
+
+**Step 7:** You can find the test log details directly in your selected Google Chat Space as shown below.
+
+
+
+## Uninstalling The Google Chat Integration
+
+***
+
+**Step 1:** Sign in to your account and visit Integrations from the left sidebar menu.
+
+**Step 2:** From the My Integrations section, click the remove option under the Google Chat block.
+
+
+
+
+That was all you need to know for + Google Chat 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!
+
diff --git a/docs/google-cloud-ci-integration.mdx b/docs/google-cloud-ci-integration.mdx
new file mode 100644
index 000000000..bc8f2f757
--- /dev/null
+++ b/docs/google-cloud-ci-integration.mdx
@@ -0,0 +1,161 @@
+---
+title: "How to run selenium test with google cloud CI"
+sidebarTitle: "Google Cloud CI"
+description: "This documentation will help you in integrating Selenium test suites with Google Cloud CI and perform automated testing on cloud Selenium grid."
+keywords: ['ci cd google cloud', 'ci cd pipeline google cloud', 'google cloud ci selenium', 'google cloud ci', 'testmu ai integration with google cloud ci']
+"og:description": "This documentation will help you in integrating Selenium test suites with Google Cloud CI and perform automated testing on cloud Selenium grid."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Google Cloud Platform is one of the market’s leading public cloud providers and offers a variety of management services. Google Cloud Build and Google Cloud Run are two Google Cloud services that use pipelines to automate builds and deployments.
+
+Integrate your Selenium test suites with Google Cloud CI and perform automated cross-browser testing on [online Selenium Grid](https://www.lambdatest.com/selenium-automation) over 3000+ real browser environments. With this integration, you can also perform local testing of locally or privately hosted projects and Parallel testing to cut short test execution cycles and achieve faster go-to-market delivery.
+
+## Prerequisites
+***
+
+Before integrating Google Cloud CI with , make sure you have the following things:
+
+1. A GitHub or a BitBucket repository. All the code samples in this documentation can be found at [ Google Cloud CI](https://github.com/LambdaTest/Java-TestNG-Selenium) repository on GitHub .
+
+2. To integrate test suites with Google Cloud CI, you would need to set your username and access key in environment variables. You can get them from [Automation Dashboard](https://automation.lambdatest.com/) by clicking on the Key button from the top-right.
+
+* **For Windows:**
+ ```
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+ set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+ ```
+
+* **For Mac/Linux:**
+ ```
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+ export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+ ```
+
+## Integrating A GitHub Repository With Google Cloud CI
+***
+
+To integrate Google Cloud CI with , you will need to fork the above Google Cloud CI repository.
+
+1. Go to the Google Cloud CI console and select **'Cloud Build'**.
+
+
+
+2. Once you're in the Cloud Build, click on **'Triggers'**.
+
+
+
+3. To use the trigger functionality, you will need to connect your GitHub repository to Google Cloud CI instance. Click on **'Connect Repository'**.
+
+
+
+Once you click on Connect Repository, you will need to complete the steps in order to connect your repository.
+
+
+
+## Running Single Test Via Google Cloud CI
+
+* * *
+
+1. After connecting to the repository, click on **'Create Trigger'**.
+
+
+
+* Provide a Trigger name.
+
+
+
+* Select the repository's source and then select the branch.
+
+
+
+* Under the **'Configuration'**, select _**Cloud Build configuration file (yaml or json)**_.
+
+
+
+* In the **'Advanced'** category, click on **'Add Variable'**.
+
+
+
+Enter your Username and Access Key in the provided field and then click on **'Create'**.
+
+
+
+2. Your trigger project will be created on the selected Google Cloud CI GitHub repository. To run the single test through Google Cloud CI, click on **'Run'**.
+
+
+
+A new build can be seen in the Google Cloud CI console. The current status of this build will be ‘Running’ or ‘Successful’.
+
+
+
+You can also view the detailed insights of your test execution on [ Automation dashboard](https://automation.lambdatest.com/timeline/).
+
+## Running Parallel Test Via Google Cloud CI
+
+* * *
+
+To run parallel tests on cloud, you will need to make minor tweaks in `cloudbuild.yml` file.
+
+```
+steps:
+- name: gcr.io/cloud-builders/docker
+ args: ['run' , '-d', '--name=lt', '--network=cloudbuild', 'lambdatest/tunnel', '--user', '${_LT_USERNAME}', '--key', '${_LT_ACCESS_KEY}', '--tunnelName', 'GCloud', '--infoAPIPort', '15000','--load-balanced']
+- name: curlimages/curl
+ args: ['-s', '--retry-connrefused', '--connect-timeout', '5', '--max-time', '5', '--retry', '30', '--retry-delay', '2', '--retry-max-time', '60', 'http://lt:15000/api/v1.0/info']
+- name: 'ubuntu'
+ args: ['sleep', '20']
+- name: 'bash'
+ args: ['ls']
+- name: 'maven'
+ entrypoint: 'mvn'
+ args: ['test', '-P', 'parallel']
+ env:
+ - 'LT_USERNAME=${_LT_USERNAME}'
+ - 'LT_ACCESS_KEY=${_LT_ACCESS_KEY}'
+```
+
+In the above YAML code, you need to add the following command to **args**.
+
+`mvn test -P parallel`
+
+Below is the screenshot of the above-executed parallel tests.
+
+
+
+## Running Local Test Via Google Cloud CI
+
+* * *
+
+To run local tests on cloud, you will need to make minor tweaks in `cloudbuild.yml` file.
+
+```
+steps:
+- name: gcr.io/cloud-builders/docker
+ args: ['run' , '-d', '--name=lt', '--network=cloudbuild', 'lambdatest/tunnel', '--user', '${_LT_USERNAME}', '--key', '${_LT_ACCESS_KEY}', '--tunnelName', 'GCloud', '--infoAPIPort', '15000','--load-balanced']
+- name: curlimages/curl
+ args: ['-s', '--retry-connrefused', '--connect-timeout', '5', '--max-time', '5', '--retry', '30', '--retry-delay', '2', '--retry-max-time', '60', 'http://lt:15000/api/v1.0/info']
+- name: 'ubuntu'
+ args: ['sleep', '20']
+- name: 'bash'
+ args: ['ls']
+- name: 'maven'
+ entrypoint: 'mvn'
+ args: ['test', '-P', 'local']
+ env:
+ - 'LT_USERNAME=${_LT_USERNAME}'
+ - 'LT_ACCESS_KEY=${_LT_ACCESS_KEY}'
+```
+
+Add the below command to **args**.
+
+`mvn test -P local`
+
+Below is the screenshot of the above-executed local tests.
+
+
+
+That's all! Ship your quality product faster using and Google Cloud CI integration. In case you have any queries for us, feel free to drop them at our window.openLTChatWidget()}>24*7 Customer Chat Support or you can also mail us at [support@testmuai.com](mailto:support@testmuai.com). Happy Testing!
diff --git a/docs/gradle-integration-with-lambdatest.mdx b/docs/gradle-integration-with-lambdatest.mdx
new file mode 100644
index 000000000..09f16df57
--- /dev/null
+++ b/docs/gradle-integration-with-lambdatest.mdx
@@ -0,0 +1,98 @@
+---
+title: "Gradle Plugin Integration With TestMu AI"
+sidebarTitle: "Gradle Plugin"
+keywords: ['testmu ai integrations', 'push issues to localstack', 'free cross browser testing tool', 'cross platform testing tools', 'check browser compatibility online', 'testmu ai gradle integration', 'integrate gradle with testmu ai', 'create issue in gradle from testmu ai', 'gradle integration with testmu ai', 'bug tracking tools', 'project management tools']
+description: "Automate testing at scale! Integrate TestMu AI with Gradle for seamless CI/CD & lightning-fast execution."
+"og:description": "Automate testing at scale! Integrate TestMu AI with Gradle for seamless CI/CD & lightning-fast execution."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+Gradle is a build automation tool for multi-language software development. It controls the development process across various tasks, including compilation, packaging, testing, deployment, and publishing. Supported languages include Java, Kotlin, Groovy, Scala, C/C++, and JavaScript.
+
+
+
+## Steps to Setup the Gradle Plugin
+
+### Step 1: Add Gradle Plugin to the `build.gradle` file
+
+```java build.gradle
+plugins {
+ id 'io.github.lambdatest.gradle' version '1.0.7'
+}
+
+repositories {
+ maven {
+ url "https://plugins.gradle.org/m2/"
+ }
+}
+```
+
+### Step 2: Configure Parameters in `build.gradle` file
+
+```java build.gradle
+runLambdaTest {
+ username = 'YOUR_LAMBDATEST_USERNAME'
+ accessKey = 'YOUR_LAMBDATEST_ACCESS_KEY>'
+ appFilePath = 'PATH_TO_YOUR_APP_FILE'
+ testSuiteFilePath = 'PATH_TO_YOUR_TEST_SUITE'
+ device = 'YOUR_DESIRED_DEVICE_FOR_TESTING'
+ isFlutter = true //if you are running flutter dart tests
+ appId = "lt://1234343" //provide this only if you have already uploaded the app
+ testSuiteId = "lt://1223444" //provide this only if you have already uploaded the app
+}
+```
+
+### Step 3: Configure Upload APK Parameters
+With the release of version **`1.0.7`** of the `lambdatest-gradle-plugin`, users now have the option to upload their APK files directly to . Add the following configuration to build.gradle to enable APK upload:
+
+```java build.gradle
+uploadApkToLambdaTest {
+ username = 'YOUR_LAMBDATEST_USERNAME'
+ accessKey = 'YOUR_LAMBDATEST_ACCESS_KEY>'
+ appFilePath = 'PATH_TO_YOUR_APP_FILE'
+ testSuiteFilePath = 'PATH_TO_YOUR_TEST_SUITE'
+}
+```
+### Step 4: Execute the Plugin
+To run the plugin configured in build.gradle, execute the following command:
+
+```bash
+./gradlew runLambdaTest
+```
+
+If you only want to upload your APK files to , use the following command:
+
+```bash
+./gradlew uploadApkToLambdaTest
+```
+
+## Post Upload Configuration
+Once the upload process is completed, will return unique IDs for the uploaded files. These IDs can be used in the run configuration to execute your tests seamlessly.
+
+## Virtual Device Support
+The Gradle plugin now supports virtual devices. To execute tests on a virtual device, set **`isVirtualDevice: true`** in both **`runLambdaTest`** and **`uploadApkToLambdaTest`** configurations. If this flag is not provided, tests will default to running on a real device.
+
+## Supported Capabilities
+
+The Gradle Plugin supports the following capabilities:
+
+| Capability | Description | Example |
+|------------|-------------|---------|
+| `appId` | Enter the app id generated while uploading the app. | `appId= lt://APP123456789123456789` |
+| `testSuiteID` | Enter the test suite id generated while uploading the test suite. | `testSuiteID= lt://APP123456789123456789` |
+| `device` | Enter the name and OS version of the device in "DeviceName-OSVersion" format. | `device= 'Pixel 3 XL-9'` or `device= 'Galaxy S21 Ultra 5G-11'` |
+| `video` | Generate a video for all the tests that have run. | `true` or `false` |
+| `queueTimeout`| Enter the time in seconds after which you want your build to timeout from queue. | `queueTimeout= 300` |
+| `idleTimeout` | Enter the time in seconds for maximum running time on a test in the build. | `idleTimeout= 120`|
+| `deviceLog` | Boolean value to generate device logs. | `deviceLog= true` or `false` |
+| `build` | Set the name of the Espresso test build. | `My Espresso Build` |
+| `geoLocation` | Set the geolocation country code if you want to enable the same in your test. | `FR` |
+| `tunnel`, `tunnelName`| Set `tunnel` as `true` and provide the `tunnelName` as needed if you are running a tunnel. | `tunnel= true`
`tunnelName= NewTunnel`|
+| `disableAnimation` | Set `disableAnimation` to `true` if you want to disable animations for espresso tests.
Default value is `false`. | `disableAnimation= false`|
+| `clearPackageData` | Set `clearPackageData` to `true` if you want to clear the app data after each test has completed running.
Default value is `false`. | `clearPackageData= false` |
+| `singleRunnerInvocation` | Set `singleRunnerInvocation` to `true` if you want to execute test cases together with a single test runner invocation.
This can help significantly speed up the test execution time. By default, each test case is invoked separately.
Default value is `false`.| `singleRunnerInvocation= true` |
diff --git a/docs/gradle-integration-with-testmu.mdx b/docs/gradle-integration-with-testmu.mdx
new file mode 100644
index 000000000..c5c40fee1
--- /dev/null
+++ b/docs/gradle-integration-with-testmu.mdx
@@ -0,0 +1,104 @@
+---
+title: "Gradle Plugin Integration With TestMu AI"
+sidebarTitle: "Gradle Plugin"
+description: "Automate testing at scale! Integrate TestMu AI with Gradle for seamless CI/CD & lightning-fast execution."
+keywords: ['testmu ai integrations', 'push issues to localstack', 'free cross browser testing tool', 'cross platform testing tools', 'check browser compatibility online', 'testmu ai gradle integration', 'integrate gradle with testmu ai', 'create issue in gradle from testmu ai', 'gradle integration with testmu ai', 'bug tracking tools', 'project management tools']
+"og:description": "Automate testing at scale! Integrate TestMu AI with Gradle for seamless CI/CD & lightning-fast execution."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Gradle is a build automation tool for multi-language software development. It controls the development process across various tasks, including compilation, packaging, testing, deployment, and publishing. Supported languages include Java, Kotlin, Groovy, Scala, C/C++, and JavaScript.
+
+
+
+## Steps to Setup the Gradle Plugin
+
+### Step 1: Add Gradle Plugin to the `build.gradle` file
+
+```java title="build.gradle"
+plugins {
+ id 'io.github.lambdatest.gradle' version '1.0.7'
+}
+
+repositories {
+ maven {
+ url "https://plugins.gradle.org/m2/"
+ }
+}
+```
+
+### Step 2: Configure Parameters in `build.gradle` file
+
+```java title="build.gradle"
+runLambdaTest {
+ username = 'YOUR_LAMBDATEST_USERNAME'
+ accessKey = 'YOUR_LAMBDATEST_ACCESS_KEY>'
+ appFilePath = 'PATH_TO_YOUR_APP_FILE'
+ testSuiteFilePath = 'PATH_TO_YOUR_TEST_SUITE'
+ device = 'YOUR_DESIRED_DEVICE_FOR_TESTING'
+ isFlutter = true //if you are running flutter dart tests
+ appId = "lt://1234343" //provide this only if you have already uploaded the app
+ testSuiteId = "lt://1223444" //provide this only if you have already uploaded the app
+}
+```
+
+### Step 3: Configure Upload APK Parameters
+With the release of version **`1.0.7`** of the `lambdatest-gradle-plugin`, users now have the option to upload their APK files directly to . Add the following configuration to build.gradle to enable APK upload:
+
+```java title="build.gradle"
+uploadApkToLambdaTest {
+ username = 'YOUR_LAMBDATEST_USERNAME'
+ accessKey = 'YOUR_LAMBDATEST_ACCESS_KEY>'
+ appFilePath = 'PATH_TO_YOUR_APP_FILE'
+ testSuiteFilePath = 'PATH_TO_YOUR_TEST_SUITE'
+}
+```
+### Step 4: Execute the Plugin
+To run the plugin configured in build.gradle, execute the following command:
+
+```bash
+./gradlew runLambdaTest
+```
+
+If you only want to upload your APK files to , use the following command:
+
+```bash
+./gradlew uploadApkToLambdaTest
+```
+
+## Post Upload Configuration
+Once the upload process is completed, will return unique IDs for the uploaded files. These IDs can be used in the runTestMu AI configuration to execute your tests seamlessly.
+
+## Virtual Device Support
+The Gradle plugin now supports virtual devices. To execute tests on a virtual device, set **`isVirtualDevice: true`** in both **`runLambdaTest`** and **`uploadApkToLambdaTest`** configurations. If this flag is not provided, tests will default to running on a real device.
+
+## Supported Capabilities
+
+The Gradle Plugin supports the following capabilities:
+
+| Capability | Description | Example |
+|------------|-------------|---------|
+| `appId` | Enter the app id generated while uploading the app. | `appId= lt://APP123456789123456789` |
+| `testSuiteID` | Enter the test suite id generated while uploading the test suite. | `testSuiteID= lt://APP123456789123456789` |
+| `device` | Enter the name and OS version of the device in "DeviceName-OSVersion" format. | `device= 'Pixel 3 XL-9'` or `device= 'Galaxy S21 Ultra 5G-11'` |
+| `video` | Generate a video for all the tests that have run. | `true` or `false` |
+| `queueTimeout`| Enter the time in seconds after which you want your build to timeout from queue. | `queueTimeout= 300` |
+| `idleTimeout` | Enter the time in seconds for maximum running time on a test in the build. | `idleTimeout= 120`|
+| `deviceLog` | Boolean value to generate device logs. | `deviceLog= true` or `false` |
+| `build` | Set the name of the Espresso test build. | `My Espresso Build` |
+| `geoLocation` | Set the geolocation country code if you want to enable the same in your test. | `FR` |
+| `tunnel`, `tunnelName`| Set `tunnel` as `true` and provide the `tunnelName` as needed if you are running a tunnel. | `tunnel= true`
`tunnelName= NewTunnel`|
+| `disableAnimation` | Set `disableAnimation` to `true` if you want to disable animations for espresso tests.
Default value is `false`. | `disableAnimation= false`|
+| `clearPackageData` | Set `clearPackageData` to `true` if you want to clear the app data after each test has completed running.
Default value is `false`. | `clearPackageData= false` |
+| `singleRunnerInvocation` | Set `singleRunnerInvocation` to `true` if you want to execute test cases together with a single test runner invocation.
This can help significantly speed up the test execution time. By default, each test case is invoked separately.
Default value is `false`.| `singleRunnerInvocation= true` |
diff --git a/docs/group-and-filter-your-test-builds-using-build-tags.mdx b/docs/group-and-filter-your-test-builds-using-build-tags.mdx
new file mode 100644
index 000000000..d217e08b9
--- /dev/null
+++ b/docs/group-and-filter-your-test-builds-using-build-tags.mdx
@@ -0,0 +1,85 @@
+---
+title: "Group and Filter Your Test Builds Using Build Tags"
+sidebarTitle: "Group Builds with Build Tags"
+description: "Now group your tests and organize them efficiently with the help of Build Tags on TestMu AI. Create one or more build tags, and filter them with just a click."
+keywords: ['testmu ai automation', 'selenium automation grid', 'selenium grid online', 'online selenium automation', 'selenium automation grid online', 'testmu ai selenium automation grid', 'selenium tutorial', 'selenium getting started', 'testmu ai getting started', 'filter tests', 'Build tags', 'group tests', 'filter test builds', 'group test builds']
+"og:description": "Now group your tests and organize them efficiently with the help of Build Tags on TestMu AI. Create one or more build tags, and filter them with just a click."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+With , now you can group your test builds with Build tags. This document shows how you can create Build tags and use them to group or filter your test builds on the Automation Dashboard.
+
+## How To Create Build Tags?
+
+
+While writing your automation tests, you need to just add another capability when you create the [Desired Capabilities](/support/docs/selenium-automation-capabilities/) via code. Just follow the below steps to do so:
+
+* Create an array of String(s), that contains your Build tags, each separated by a comma.
+
+ ```java
+ // For example, when you have only 1 tag
+ String[] buildTagList = {"Build Tag"};
+
+ // For example, when you have multiple tags
+ String[] buildTagList = {"Tag 1", "Tag 2", "Tag 3", ...};
+ ```
+
+
+* Now you just need to add this Build tag array in your Desired Capabilities instance, as shown below: **For example:** While creating a sample Desired Capabilities instance in Java, the code will be:
+
+ ```java
+ // Creating the Build Tags
+ String[] buildTagList = {"Tag1", "Tag2", "Tag3", "BuildTagRishabh"};
+
+ DesiredCapabilities caps = new DesiredCapabilities();
+ caps.setCapability("browser", "Safari");
+ caps.setCapability("version", "13");
+ caps.setCapability("platform", "macos Catalina");
+ caps.setCapability("build", "Build Tags Demo");
+ caps.setCapability("name", "Sample Test");
+
+ // To create custom tags
+ caps.setCapability("buildTags", buildTagList);
+
+ System.out.println("Desired Caps: " + caps);
+ driver = new RemoteWebDriver(new URL("https://" + username + ":" + authkey + hub), caps);
+ ```
+
+You have successfully created the Build tags. Now when you run your test, and navigate to [ Automation Dashboard](https://automation.lambdatest.com/timeline/), you can see the tags being present in that build, as shown below:
+
+
+
+## Guildelines To Create Build Tags On ?
+
+While creating Build Tags, make sure to follow the below Guidelines:
+
+* Maximum of 5 custom tags can be added to a build.
+* User can update the existing build by specifying different tags
+* If you change tag name, or number of tags, no new build will be created. Rather the existing build will be updated with a new tag, to avoid unnecessary build creation and exploitation of new build creation.
+
+## How To Filter Tests Using Build Tags?
+
+* * *
+
+To group or filter the tests on your automation dashboard with these Build tags:
+
+Navigate to [ Automation Dashboard](https://automation.lambdatest.com/timeline/), and you can see a filter by name **Build Tags**, on right corner of the filter toolbar.
+
+
+Select the Build tag by which you want to filter your test. For example, if we choose _Tag1_, as shown below, only the test builds with the tag "Tag1" will be shown:
+
+
+
+You can choose multiple Build tags as well to filter your tests effectively, as shown in the image below:
+
+
+
+* * *
+
+
+That's it! You have successfully created a Build tag, and grouped and filtered your tests based on these Build tags. If you still have any questions, feel free to share them with us through our window.openLTChatWidget()}>**24/7 chat support** or by mailing to us on [support@testmuai.com](mailto:support@testmuai.com). Happy testing! :)
+
diff --git a/docs/group-folder-redirect-on-real-device.mdx b/docs/group-folder-redirect-on-real-device.mdx
new file mode 100644
index 000000000..a4f03a8d3
--- /dev/null
+++ b/docs/group-folder-redirect-on-real-device.mdx
@@ -0,0 +1,39 @@
+---
+title: Group Folder Redirect On Real Devices
+sidebarTitle: "Redirect Group Folders"
+keywords: ['testmu ai real devices', 'ios app live', 'group folder redirect', 'ios file system testing', 'private app container testing']
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+ supports **Group Folder Redirect** for iOS apps on Real Devices.
+This feature ensures your app uses its **private container directory** instead of the **shared app group container**, which becomes inaccessible after **app resigning** on Real Devices.
+
+---
+
+## Use Cases
+
+- Ensure your app maintains **file system access** after being re-signed on Real Devices.
+- Prevent issues when your app relies on the **shared App Group container**, which becomes inaccessible after resigning.
+- Guarantee consistent **storage and retrieval of files** by using the app’s private container.
+
+---
+
+## Using Group Folder Redirect in Manual Testing
+
+**Step 1**: Click on the Real Devices > App Testing
+
+**Step 2**: Upload your application. Open the **App Settings** to enable the **Group Folder Redirect** toggle.
+
+
+
+**Step 4**: Select your device and start your Real Device testing session.
+
+---
+
+
+- An **instrumented version** of your app with Group Folder Redirect support will launch.
+- The app will store and retrieve files from its **private container directory** instead of the shared App Group container.
+- File system features will function consistently even after app resigning.
+
diff --git a/docs/group-folder-redirect-on-real-devices.mdx b/docs/group-folder-redirect-on-real-devices.mdx
new file mode 100644
index 000000000..638c10265
--- /dev/null
+++ b/docs/group-folder-redirect-on-real-devices.mdx
@@ -0,0 +1,42 @@
+---
+title: "Group Folder Redirect for iOS Apps in App Live"
+sidebarTitle: "Group Folder Redirect"
+description: "Enable Group Folder Redirect support for iOS apps on TestMu AI Real Devices."
+keywords: ['testmu ai real devices', 'ios app live', 'group folder redirect', 'ios file system testing', 'private app container testing']
+"og:description": "Enable Group Folder Redirect support for iOS apps on TestMu AI Real Devices."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+ supports **Group Folder Redirect** for iOS apps on Real Devices.
+This feature ensures your app uses its **private container directory** instead of the **shared app group container**, which becomes inaccessible after **app resigning** on Real Devices.
+
+---
+
+## Use Cases
+
+- Ensure your app maintains **file system access** after being re-signed on Real Devices.
+- Prevent issues when your app relies on the **shared App Group container**, which becomes inaccessible after resigning.
+- Guarantee consistent **storage and retrieval of files** by using the app’s private container.
+
+---
+
+## Using Group Folder Redirect in Manual Testing
+
+**Step 1**: Click on the Real Devices > App Testing
+
+**Step 2**: Upload your application. Open the **App Settings** to enable the **Group Folder Redirect** toggle.
+
+
+
+**Step 4**: Select your device and start your Real Device testing session.
+
+---
+
+- An **instrumented version** of your app with Group Folder Redirect support will launch. **
+
+- The app will store and retrieve files from its **private container directory** instead of the shared App Group container.
+- File system features will function consistently even after app resigning.
+
diff --git a/docs/group-folder-redirect.mdx b/docs/group-folder-redirect.mdx
new file mode 100644
index 000000000..35b1abc3c
--- /dev/null
+++ b/docs/group-folder-redirect.mdx
@@ -0,0 +1,70 @@
+---
+title: "Group Folder Redirect for iOS Apps in Appium Tests"
+sidebarTitle: "Group Folder Redirect"
+description: "Learn how to enable Group Folder Redirect for iOS apps during Appium testing on TestMu AI Real Device Cloud."
+keywords: ['testmu ai automation', 'ios app automation', 'group folder redirect', 'appium ios file system testing', 'private app container automation']
+"og:description": "Learn how to enable Group Folder Redirect for iOS apps during Appium testing on TestMu AI Real Device Cloud."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+import { RealDeviceTag } from '/snippets/RealDeviceTag.mdx';
+
+
+ now supports **Group Folder Redirect** for iOS apps during automation testing with Appium.
+This feature ensures your app uses its **private container directory** instead of the **shared app group container**, which becomes inaccessible after **app resigning** on Real Devices.
+
+---
+
+ ## Use Cases
+
+- Ensure your app maintains **file system access** after being re-signed on Real Devices.
+- Prevent issues when your app relies on the **shared App Group container**, which becomes inaccessible after resigning.
+- Guarantee consistent **storage and retrieval of files** by using the app’s private container.
+
+---
+
+## Steps to Enable Group Folder Redirect
+
+### 1. Upload Your Application
+- Upload your iOS app to following standard procedures.
+- Refer to the [**Upload your Application**](/support/docs/application-setup-via-api/#upload-your-application) documentation for detailed instructions.
+- Note the **App ID** returned after uploading — you will use this in your automation scripts.
+
+---
+
+### 2. Configure Desired Capabilities
+Include the `groupFolderRedirectEnabled` capability in your Appium desired capabilities and set it to `True`.
+
+
+
+ ```java
+
+desired_caps = {
+ "deviceName":"iPhone 16",
+ "platformName":"iOS",
+ "platformVersion":"18",
+ "isRealMobile": True,
+ "app":"YOUR_APP_URL",
+ "build":"Sample Build",
+ "name":"Sample Test",
+ #highlight-next-line
+ "groupFolderRedirectEnabled": True
+}
+
+```
+
+
+
+---
+
+### 3. Run Your Automation Test
+Launch your Appium test, the app will automatically use its private container for all file operations without any code changes.
+
+---
+
+
+- launches an **instrumented version** of your app with **Group Folder Redirect** support. **
+
+- All file system operations that previously relied on the App Group container now use the **private container**.
+- Your tests remain compatible and functional, even after app resigning.
+
diff --git a/docs/group-folder-redirects.mdx b/docs/group-folder-redirects.mdx
new file mode 100644
index 000000000..fb14955bc
--- /dev/null
+++ b/docs/group-folder-redirects.mdx
@@ -0,0 +1,64 @@
+---
+title: "Group Folder Redirect for iOS Apps"
+sidebarTitle: "Group Folder Redirect"
+keywords: ['lambdatest automation', 'ios app automation', 'group folder redirect', 'appium ios file system testing', 'private app container automation']
+---
+
+import { RealDeviceTag } from '/snippets/RealDeviceTag.mdx';
+import { VirtualDeviceTag } from '/snippets/VirtualDeviceTag.mdx';
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+
+
+
+ now supports **Group Folder Redirect** for iOS apps during automation testing with Appium.
+This feature ensures your app uses its **private container directory** instead of the **shared app group container**, which becomes inaccessible after **app resigning** on Real Devices.
+
+---
+
+ ## Use Cases
+
+- Ensure your app maintains **file system access** after being re-signed on Real Devices.
+- Prevent issues when your app relies on the **shared App Group container**, which becomes inaccessible after resigning.
+- Guarantee consistent **storage and retrieval of files** by using the app’s private container.
+
+---
+
+## Steps to Enable Group Folder Redirect
+
+### 1. Upload Your Application
+- Upload your iOS app to following standard procedures.
+- Refer to the [**Upload your Application**](/support/docs/application-setup-via-api/#upload-your-application) documentation for detailed instructions.
+- Note the **App ID** returned after uploading — you will use this in your automation scripts.
+
+---
+
+### 2. Configure Desired Capabilities
+Include the `groupFolderRedirectEnabled` capability in your Appium desired capabilities and set it to `True`.
+
+```python iOS highlight={9}
+desired_caps = {
+ "deviceName":"iPhone 16",
+ "platformName":"iOS",
+ "platformVersion":"18",
+ "isRealMobile": True,
+ "app":"YOUR_APP_URL",
+ "build":"Sample Build",
+ "name":"Sample Test",
+ "groupFolderRedirectEnabled": True
+}
+```
+
+---
+
+### 3. Run Your Automation Test
+Launch your Appium test, the app will automatically use its private container for all file operations without any code changes.
+
+---
+
+
+- launches an **instrumented version** of your app with **Group Folder Redirect** support.
+- All file system operations that previously relied on the App Group container now use the **private container**.
+- Your tests remain compatible and functional, even after app resigning.
+
diff --git a/docs/group-management.mdx b/docs/group-management.mdx
new file mode 100644
index 000000000..20396deae
--- /dev/null
+++ b/docs/group-management.mdx
@@ -0,0 +1,85 @@
+---
+title: "Group Management"
+sidebarTitle: "Group Management"
+description: "This documentation will help you in creating the different groups and allot concurrency to those groups to perform test automation easily."
+keywords: ['group-management-control', 'testmu ai']
+"og:description": "This documentation will help you in creating the different groups and allot concurrency to those groups to perform test automation easily."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+{/* For every enterprise that uses cloud services, access management for those cloud resources is vital. Group Management is an authorization system that allows seamless access management of resources. With group-management, you can control who has access to resources, how they can leverage those resources, and what domains they can have access to. */}
+
+The Group Management will help you in creating the different Groups and allot concurrency to those groups. In this way, you can perform the test automation by dividing the concurrency among the groups.
+
+## How to Create a New Group?
+***
+
+**Step 1:** Login to your [](https://accounts.lambdatest.com/dashboard) account and navigate to Profile icon on the top-right. Click on ***Organization Settings***.
+
+
+
+**Step 2:** Select the 'Groups' tab and click on '+ Create'.
+
+
+
+**Step 3:** Fill in the group name of your choice, allot the maximum concurrency using the sliders. After providing the details, click on 'Next'.
+
+
+
+**Step 4:** Select users you want to add to the group, click on 'Next'.
+
+
+
+**Step 5:** Review the list of users you have selected to add to the group, then click on 'Finish'. Your new group will be created successfully.
+
+
+
+## How to View and Edit a Group?
+***
+
+**Step 1:** Login to your account and navigate to Profile icon on the top-right. Click on ***Organization Settings***.
+
+
+
+**Step 2:** Click on the 'Groups' tab, select the desired group you want to view and edit. Click on the 3 dots and then select 'Edit' button.
+
+
+
+**Step 3:** You can view and edit the Group Name and Concurrency settings. After making changes, click on 'Next' to proceed.
+
+
+
+**Step 4:** You can add or remove users from the group. Select or deselect users as needed, then click on 'Add Users' or 'Save Changes' to save your modifications.
+
+
+
+{/* ## How to Edit a Group?
+***
+
+**Step 1:** Login to your account and navigate to Profile icon on the top-right. Click on 'Organizational Settings'.
+
+
*/}
+
+## How to Delete a Group?
+***
+
+**Step 1:** Login to your account and navigate to Profile icon on the top-right. Click on ***Organization Settings***.
+
+
+
+**Step 2:** Click on the 'Groups' tab, select the desired group you want to delete. Click on the 3 dots and then select 'Delete' button.
+
+
+
+**Step 3:** A confirmation dialog will appear. Click on the 'Delete' button to confirm. Your selected group will be deleted.
+
+
+
+
+
+
+In case you have any queries regarding Group Management or need any additional information, please reach out at our 24*7 Chat Portal or drop us a mail to support@testmuai.com.
+
diff --git a/docs/group-tests-using-custom-tags.mdx b/docs/group-tests-using-custom-tags.mdx
new file mode 100644
index 000000000..9bba23b22
--- /dev/null
+++ b/docs/group-tests-using-custom-tags.mdx
@@ -0,0 +1,85 @@
+---
+title: "How To Create Custom Automation Tags"
+sidebarTitle: "Group Tests with Custom Tags"
+description: "Now group your tests and organize them efficiently with the help of Custom Tags. TestMu AI allows you to create custom tags and filter them with a click."
+keywords: ['TestMu AI automation', 'selenium automation grid', 'selenium grid online', 'online selenium automation', 'selenium automation grid online', 'TestMu AI selenium automation grid', 'selenium tutorial', 'Selenium getting started', 'testmu ai getting started', 'filter tests', 'custom tags', 'group tests']
+"og:description": "Now group your tests and organize them efficiently with the help of Custom Tags. TestMu AI allows you to create custom tags and filter them with a click."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+ allows you to group your automation tests using custom tags. In this document, we will see how to create custom tags and use them. For demonstration purposes, we have used a [sample TestNG script](https://github.com/LambdaTest/Java-TestNG-Selenium) to run on the platform.
+
+## How To Create Custom Tags While Performing Automation On Selenium Grid?
+
+
+You can create a custom tag using a simple step. While writing your Selenium automation tests, when you create the [Desired Capabilities](/support/docs/selenium-automation-capabilities/) via code, just add the below lines of code.
+
+* Create a String array that contains the names of your custom tags, separated by a comma.
+```javascript
+ // In case for just 1 tag, just add 1 element in the array
+ String[] customTags = {"Custom Tag"};
+
+ // In case for multiple tags, add them in the array separated by comma
+ String[] customTags = {"Tag 1", "Tag 2", "Tag 3", ...};
+```
+
+* Now you just need to add this custom tag in your Desired Capabilities instance, as shown below:
+```javascript
+ DesiredCapabilities caps = new DesiredCapabilities();
+ .
+ .
+
+ // To create custom tags
+ caps.setCapability("tags", customTags);
+ ```
+*For example:*
+
+
+
+You have successfully created the custom tags. Let's now see how to view the custom tags and how to group the test based on custom tags in the below section.
+
+## How To View Custom Tags On Platform?
+
+* * *
+
+There are multiple ways by which you can view the custom tags in the automation dashboard, such as Timeline view and Automation logs view. We will see one by one, how to view the custom tags in each of these.
+
+### How To View Custom Tags On Your Timeline?
+
+Navigate to [Timeline](https://automation.lambdatest.com/timeline/) view of your automation dashboard, and toggle the **Build View** to **Test View**, as shown in the image below:
+
+
+
+You can see the applied custom tags below the tests in this Test View.
+
+### How To View Custom Tags On Your Automation Logs?
+
+* * *
+
+Navigate to [Automation Logs](https://automation.lambdatest.com/logs) of your automation dashboard, and you can see the applied custom tags below the tests in the left panel.
+
+## How To Filter Tests Using Custom Tags On Platform?
+
+* * *
+
+You can also filter the tests on your automation dashboard with the help of these custom tags. Let us see how.
+
+Navigate to [Automation Logs](https://automation.lambdatest.com/logs) of your automation dashboard, and you can see a filter by name **Tags** in the filter toolbar.
+
+Click on it and select the Tag by which you want to filter the tests on your dashboard. For example, we have filtered the test using _Tag2_ custom tag, as shown in the image below:
+
+
+
+You can even filter the tests by selecting multiple custom tags at once, from the filter toolbar, as shown in the image below:
+
+
+
+* * *
+
+
+Kudos! You have successfully created a custom tag and grouped your tests based on the custom tag. If you still have any questions, feel free to share them with us through our window.openLTChatWidget()}>**24/7 chat support** or by mailing to us on [support@testmuai.com](mailto:support@testmuai.com). Happy testing! :)
+
diff --git a/docs/guide-to-nodejs.mdx b/docs/guide-to-nodejs.mdx
new file mode 100644
index 000000000..5abdb0d5f
--- /dev/null
+++ b/docs/guide-to-nodejs.mdx
@@ -0,0 +1,128 @@
+---
+title: "Guide:Running NodeJS Tests On Cloud Selenium Grid"
+sidebarTitle: "Quick Guide To Run Node.js"
+description: "Guide to running Node.js and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and Node.js on 3000+ browsers on cloud."
+keywords: ['testmu ai automation using Node.js', 'Node.js and Selenium automation', 'Node.js documentation testmu ai', 'node.js and selenium tutorial', 'node.js and testmu ai tutorial', 'node.js on testmu ai selenium grid', 'getting started with node.js and selenium', 'selenium testing using node.js', 'node.js selenium scripts']
+"og:description": "Guide to running Node.js and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and Node.js on 3000+ browsers on cloud."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+’s [Selenium grid](https://www.lambdatest.com/blog/why-selenium-grid-is-ideal-for-automated-browser-testing/) enables you to perform end-to-end automation tests on a secure, reliable, and scalable Selenium cloud infrastructure. You can run your Node.js automation test scripts on 3000+ browser and operating system environments giving you higher test coverage and significantly less built times. This document will help you quickly get started with running your Node.js test scripts on the Selenium automation grid.
+
+## Prerequisites
+***
+
+- The first step is to download and install Node.js and node package manager or npm. We recommend using the latest version of node.js.
+
+- You can download it from [official NodeJS website](https://nodejs.org/en/).
+
+- If you have npm already installed, you may want to upgrade it to the latest version. Here the code you can run in your terminal to upgrade npm.
+
+ npm install npm@latest -g
+
+## Installing Selenium Dependencies For Node.js
+***
+
+The next step is to install Selenium dependencies for Node.js using npm. Here’s the command that you can run:
+
+ npm i selenium-webdriver
+
+## Sample Node.js & Selenium Test To Get You Started
+***
+
+Once you have installed the necessary dependencies, you are all set to run your Node.js automation scripts on the Selenium grid. To get started, you can try out the code below. It’s a simple Node.js script that opens up Google.com, searches in Google search, and then outputs the search result page's title. You can also fork it from our [Node.js GitHub repository](https://github.com/LambdaTest/nodejs-selenium-sample). Make sure to create the JS file in the same folder where you have downloaded Selenium.
+
+## Sample Node.js & Selenium Automation Script
+***
+
+Do make sure to add the **Username** and **Key** in the code below. You can find your username and access key using the key icon on the [Automation dashboard](https://automation.lambdatest.com/) or in your [Profile](https://accounts.lambdatest.com/detail/profile) section.
+
+```javascript
+/*
+ TestMu AI selenium automation sample example
+ Configuration
+ ----------
+ username: Username can be found at automation dashboard
+ accessKey: AccessKey can be generated from automation dashboard or profile section
+
+ Result
+ -------
+ Execute NodeJS Automation Tests on TestMu AI Distributed Selenium Grid
+*/
+const webdriver = require('selenium-webdriver');
+
+/*
+ Setup remote driver
+ Params
+ ----------
+ platform : Supported platform - (Windows 10, Windows 8.1, Windows 8, Windows 7, macOS High Sierra, macOS Sierra, OS X El Capitan, OS X Yosemite, OS X Mavericks)
+ browserName : Supported platform - (chrome, firefox, Internet Explorer, MicrosoftEdge, Safari)
+ version : Supported list of version can be found at https://www.testmuai.com/capabilities-generator/
+*/
+
+// username: Username can be found at automation dashboard
+const USERNAME = 'YOUR_LAMBDATEST_USERNAME';
+
+// AccessKey: AccessKey can be generated from automation dashboard or profile section
+const KEY = 'YOUR_LAMBDATEST_ACCESS_KEY';
+
+// gridUrl: gridUrl can be found at automation dashboard
+const GRID_HOST = 'hub.lambdatest.com/wd/hub';
+
+function searchTextOnGoogle() {
+ // Setup Input capabilities
+ const capabilities = {
+ platform: 'windows 10',
+ browserName: 'chrome',
+ version: '67.0',
+ resolution: '1280x800',
+ network: true,
+ visual: true,
+ console: true,
+ video: true,
+ name: 'Test 1', // name of the test
+ build: 'NodeJS build' // name of the build
+ }
+
+ // URL: https://{username}:{accessKey}@hub.lambdatest.com/wd/hub
+ const gridUrl = 'https://' + USERNAME + ':' + KEY + '@' + GRID_HOST;
+
+ // setup and build selenium driver object
+ const driver = new webdriver.Builder()
+ .usingServer(gridUrl)
+ .withCapabilities(capabilities)
+ .build();
+
+ // navigate to a url, search for a text and get title of page
+ driver.get('https://www.google.com/ncr').then(function() {
+ driver.findElement(webdriver.By.name('q')).sendKeys('TestMu AI\n').then(function() {
+ driver.getTitle().then(function(title) {
+ setTimeout(function() {
+ console.log(title);
+ driver.quit();
+ }, 5000);
+ });
+ });
+ });
+}
+searchTextOnGoogle();
+```
+You can execute the test from your terminal through this command.
+
+ node index.js
+
+Do note the use of the remote webdriver here. We have passed browser environment configurations through the capabilities class. You can set the environment details as per your requirements.
+
+To set up your own choice of environment for the test in the code, you can leverage our Capability Generator tool.
+
+
+
+
+**Tear Down**: The tear down method helps the platform understand when the test’s execution is finished. It’s important to tear down each test, or else it will give timeout errors.
+
+
diff --git a/docs/guide-to-php.mdx b/docs/guide-to-php.mdx
new file mode 100644
index 000000000..313545326
--- /dev/null
+++ b/docs/guide-to-php.mdx
@@ -0,0 +1,161 @@
+---
+title: "Running PHP Tests on Online Selenium Grid | TestMu AI"
+sidebarTitle: "Quick Guide To Run PHP"
+description: "Guide to running PHP and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and PHP on 3000+ browsers on cloud"
+keywords: ['TestMu AI automation using php', 'php and Selenium automation', 'php documentation TestMu AI']
+"og:description": "Guide to running PHP and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and PHP on 3000+ browsers on cloud"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+'s cloud-based Selenium grid can be leveraged to run your automation test scripts on 3000+ different browser and operating system environments. It’s a scalable, reliable, and secure online [Selenium grid](https://www.lambdatest.com/selenium-automation) infrastructure that not only helps you in increasing test coverage, but also cut down execution of your test automation builds by significant margin. This post will help you get started with running your PHP based Selenium automation scripts on Selenium grid.
+
+## Prerequisites
+***
+
+Running PHP scripts require your local system to have both PHP and Composer. Here’s how you can setup your PHP environment for running Selenium scripts.
+
+- First step is to install the latest PHP build. Latest MacOS systems come with PHP pre-installed, however for windows users and linux users, you can download PHP from [here](https://www.php.net/manual/en/install.php).
+
+- Next step is to install Composer. Open up terminal and navigate to the folder that have PHP installed. Run the following command.
+
+```javascript
+php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
+php -r "if (hash_file('sha384', 'composer-setup.php') === '93b54496392c062774670ac18b134c3b3a95e5a5e5c8f1a9f115f203b75bf9a129d5daa8ba6a13e2cc8a1da0806388a8') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
+php composer-setup.php
+php -r "unlink('composer-setup.php');"
+```
+- If you are using XAMPP or MAMP, you may have to open up PHP shell by pressing the button shown in picture below:
+
+
+
+Once you have composer installed, you can leverage Composer to download and install Selenium dependencies. For that, first create a composer.json file in your directory and add the following JSON code:
+
+```javascript
+{
+ "require": {
+ "phpunit/phpunit-selenium": "*",
+ "facebook/webdriver": "dev-master"
+ }
+}
+```
+## Installing Selenium Dependencies For PHP
+***
+
+Now all you would have to do is to run composer to install Selenium. You can do that by running following command in your terminal:
+
+ composer install
+
+If you are using XAMPP or MAMP you may have to be a little more specific.
+
+ php composer.phar install
+
+## Sample PHP & Selenium Test To Get You started
+***
+
+Once you have installed and setup PHP and Selenium, you are now ready to run PHP automation scripts on Selenium Grid. Checkout the simple sample code below. This is a simple PHP and Selenium automation script that opens up google.com, searches and outputs the title of the resultant google search page. You can also fork it from our [PHP GitHub repository](https://github.com/LambdaTest/php-selenium-sample).
+
+### PHP Sample Test
+***
+
+```javascript
+setCapability('browserName',$LT_BROWSER);
+ $desired_capabilities->setCapability('version', $LT_BROWSER_VERSION);
+ $desired_capabilities->setCapability('platform', $LT_PLATFORM);
+ $desired_capabilities->setCapability('name', "Php");
+ $desired_capabilities->setCapability('build', "Php Build");
+ $desired_capabilities->setCapability('network', true);
+ $desired_capabilities->setCapability('visual', true);
+ $desired_capabilities->setCapability('video ', true);
+ $desired_capabilities->setCapability('console', true);
+
+ /*
+ Setup remote driver
+ Params
+ ----------
+ Execute test: navigate google.com search TestMu AI
+ Result
+ -------
+ print title
+ */
+ self::$driver = RemoteWebDriver::create($url, $desired_capabilities);
+
+ self::$driver->get("https://www.google.com/ncr");
+
+ $element = self::$driver->findElement(WebDriverBy::name("q"));
+ if($element) {
+ $element->sendKeys("TestMu AI");
+ $element->submit();
+ }
+
+ print self::$driver->getTitle();
+ self::$driver->quit();
+ }
+}
+
+$lambdaTest = new TestMu AI();
+$lambdaTest->searchTextOnGoogle();
+
+?>
+```
+
+You can execute the test from your terminal through this command.
+
+ vendor/bin/phpunit testmu ai.php
+
+Do note the use of remote webdriver here. We have passed browser environment configurations through capabilities class. You can set your environment details as you wish.
+
+To setup your own environment for the test you can leverage our Capability Generator tool.
+
+
+
+
+**Tear Down**: The tear down method helps platform understand when the execution of a test is finished. It’s important to tear down each test or else it will give timeout errors
+
+
diff --git a/docs/guide-to-python.mdx b/docs/guide-to-python.mdx
new file mode 100644
index 000000000..7626d724a
--- /dev/null
+++ b/docs/guide-to-python.mdx
@@ -0,0 +1,149 @@
+---
+title: "Guide - Running Python Tests On TestMu AI Selenium Grid"
+sidebarTitle: "Quick Guide To Run Python"
+description: "Guide to running Python and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and Python on 3000+ browsers on cloud"
+keywords: ['TestMu AI automation using python', 'python and Selenium automation', 'python documentation TestMu AI']
+"og:description": "Guide to running Python and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and Python on 3000+ browsers on cloud"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+ Selenium Automation Grid is a cloud based scalable [Selenium testing](https://www.lambdatest.com/selenium-automation) platform which enables you to run your automation scripts on 3000+ different browsers and operating systems. You can leverage Selenium grid to not only decrease the build time of Python automation scripts, but also increase your test coverage and check for more range of browsers for cross browser compatibility. This post will help you in getting started with configuring and running your Python based automation test scripts on Selenium cloud platform.
+
+## Prerequisites
+***
+
+- Make sure that you have the latest Python build installed. You can download the latest Python build from [this page](https://www.python.org/downloads/).
+
+- You would need Python package manager, pip, as well. Usually latest python installers come prepacked with pip. However, if you don’t have pip, you can install it using the below command:
+
+ curl https://bootstrap.pypa.io/get-pip.py | python
+
+## Installing Selenium Dependencies For Python
+***
+
+Make sure that you have installed Selenium dependencies before executing your tests. You can use pip to install Selenium using following command:
+
+ pip install selenium
+ export PYTHONWARNINGS="ignore:Unverified HTTPS request" //Disable SSL warning
+
+## Sample Python & Selenium Test To Get You started
+***
+
+Now we are all set to execute the first Python test on Selenium Grid. Checkout the sample code below. This is a simple python code that uses Selenium grid to open up Google. You can also download it from our [GitHub repo](https://github.com/LambdaTest/python-selenium-sample).
+
+### Sample Python & Selenium Automation Script
+***
+```
+"""
+TestMu AI Selenium automation sample example
+Configuration
+----------
+username: Username can be found at automation dashboard
+accessToken: AccessToken can be generated from automation dashboard or profile section
+
+Result
+-------
+Execute Python Automation Tests on TestMu AI Distributed Selenium Grid
+"""
+import unittest
+import time
+from selenium import webdriver
+from selenium.webdriver.common.keys import Keys
+
+class LTAutomate(unittest.TestCase):
+
+ """
+ Setup remote driver
+ Params
+ ----------
+ platform : Supported platform - (Windows 10, Windows 8.1, Windows 8, Windows 7, macOS High Sierra, macOS Sierra, OS X El Capitan, OS X Yosemite, OS X Mavericks)
+ browserName : Supported platform - (chrome, firefox, Internet Explorer, MicrosoftEdge)
+ version : Supported list of version can be found at https://www.testmuai.com/capabilities-generator/
+
+ Result
+ -------
+ """
+ def setUp(self):
+ # username: Username can be found at automation dashboard
+ username="YOUR_LAMBDATEST_USERNAME"
+ # accessToken: AccessToken can be generated from automation dashboard or profile section
+ accessToken="YOUR_LAMBDATEST_ACCESS_KEY"
+ # gridUrl: gridUrl can be found at automation dashboard
+ gridUrl = "hub.lambdatest.com/wd/hub"
+
+ desired_cap = {
+ 'platform' : "win10",
+ 'browserName' : "chrome",
+ 'version' : "67.0",
+ # Resolution of machine
+ "resolution": "1024x768",
+ "name": "TestMu AI python google search test ",
+ "build": "TestMu AI python google search build",
+ "network": True,
+ "video": True,
+ "visual": True,
+ "console": True,
+ }
+
+ # URL: https://{username}:{accessToken}@hub.lambdatest.com/wd/hub
+ url = "https://"+username+":"+accessToken+"@"+gridUrl
+
+ print("Initiating remote driver on platform: "+desired_cap["platform"]+" browser: "+desired_cap["browserName"]+" version: "+desired_cap["version"])
+ self.driver = webdriver.Remote(
+ desired_capabilities=desired_cap,
+ command_executor= url
+ )
+
+ """
+ Setup remote driver
+ Params
+ ----------
+ Execute test: navigate google.com search TestMu AI
+ Result
+ -------
+ print title
+ """
+ def test_search_in_google(self):
+ driver = self.driver
+ print("Driver initiated successfully. Navigate url")
+ driver.get("https://www.google.com/ncr")
+
+ print("Searching testmu ai on google.com ")
+ time.sleep(8)
+ elem = driver.find_element_by_name("q")
+ elem.send_keys("lambdatest.com")
+ elem.submit()
+
+ print("Printing title of current page :"+driver.title)
+ driver.execute_script("lambda-status=passed")
+ print("Requesting to mark test : pass")
+
+ """
+ Quit selenium driver
+ """
+ def tearDown(self):
+ self.driver.quit()
+
+if __name__ == "__main__":
+ unittest.main()
+
+```
+
+You can execute the test from your terminal through this command.
+
+ python google-search-testmu ai.py
+
+The first thing to note here, is the use of remote WebDriver. Also checkout how the test passed on the enthronement configuration via desired_cap class.
+
+To use your choice of environment for the test you can leverage our Capability Generator tool.
+
+
+
+
+**Tear Down**: The tear down method helps platform understand when the execution of a test is finished. It’s important to tear down each test or else it will give timeout errors.
+
+
diff --git a/docs/guide-to-ruby.mdx b/docs/guide-to-ruby.mdx
new file mode 100644
index 000000000..66b0aca54
--- /dev/null
+++ b/docs/guide-to-ruby.mdx
@@ -0,0 +1,136 @@
+---
+title: "How To Run Ruby Tests On Online Selenium Grid"
+sidebarTitle: "Quick Guide To Run Ruby"
+keywords: ['testmu ai automation using ruby', 'ruby and selenium automation', 'ruby documentation testmu ai', 'ruby and selenium tutorial', 'ruby and testmu ai tutorial', 'ruby on testmu ai selenium grid', 'getting started with ruby and selenium', 'selenium testing using ruby', 'ruby selenium scripts']
+description: "Guide to running Ruby and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and Ruby on 3000+ browsers on cloud."
+"og:description": "Guide to running Ruby and Selenium test scripts on TestMu AI Selenium automation grid online. Automated cross browser testing online using Selenium and Ruby on 3000+ browsers on cloud."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+***
+
+ Selenium Automation Grid is a secure, scalable, and reliable [Selenium Grid](https://www.testmuai.com/blog/why-selenium-grid-is-ideal-for-automated-browser-testing/) on cloud that can help you run your Ruby automation scripts on 3000+ different browsers and operating system environments. The grid is specifically built for high performance and gives you not only a greater browser coverage but also an ability to run automation tests in parallel. This helps you reduce your automation test execution time significantly. This post will help you quickly get started with running Ruby test scripts on Selenium Grid.
+
+## Prerequisites
+***
+
+First, you would have to install Ruby and gem on your local system. We recommend installing the latest version of Ruby. Installing these platforms is a little different in each operating system
+
+- For windows, you can download the latest installed the [official website](https://rubyinstaller.org/downloads/).
+
+- If you are using Linux or Ubuntu OS, you can run a simple apt command like below. You can also refer to this doc to know more about which command suits your OS better.
+
+ $ sudo apt-get install ruby-full
+
+- If you are using MacOS you can run a [homebrew](https://brew.sh/) command like this-
+
+ $ brew install ruby
+
+## Installing Selenium Dependencies For Ruby
+***
+
+Once you have Ruby and Gem setup, you would now have to install Selenium dependencies. You can install Selenium via simple gem command-
+
+ gem install selenium-webdriver
+
+## Sample Ruby & Selenium Test To Get You started
+***
+
+Once you have installed necessary dependencies, you are all set to run your Ruby automation scripts on Selenium grid. To get started you can try out the code below. It’s a simple Ruby scripts that opens up [Google.com](https://www.google.com/), searches in Google search bar, and then displays the title of the search result page. You can also fork it from our [Ruby GitHub repository](https://github.com/LambdaTest/ruby-selenium-sample).
+
+```ruby
+//Sample Ruby and Selenium Automation Script
+
+require 'selenium-webdriver'
+require 'test/unit'
+
+class LtTest < Test::Unit::TestCase
+ """
+ LambdaTest selenium automation sample example
+ Configuration
+ ----------
+ username: Username can be found at automation dashboard
+ accessToken: AccessToken can be generated from automation dashboard or profile section
+
+ Result
+ -------
+ Execute Ruby Automation Tests on LambdaTest Distributed Selenium Grid
+ """
+
+ def setup
+ """
+ Setup remote driver
+ Params
+ ----------
+ platform : Supported platform - (Windows 10, Windows 8.1, Windows 8, Windows 7, macOS High Sierra, macOS Sierra, OS X El Capitan, OS X Yosemite, OS X Mavericks)
+ browserName : Supported platform - (chrome, firefox, Internet Explorer, MicrosoftEdge)
+ version : Supported list of version can be found at https://www.testmuai.com/capabilities-generator/
+
+ Result
+ -------
+ """
+ username= "{YOUR_LAMBDATEST_USERNAME}"
+ accessToken= "{YOUR_LAMBDATEST_ACCESS_KEY}"
+ gridUrl = "hub.lambdatest.com/wd/hub"
+
+ caps = {
+ :browserName => "chrome",
+ :version => "67.0",
+ :platform => "win10",
+ :name => "LambdaTest ruby google search name",
+ :build => "LambdaTest ruby google search build",
+ :network => true,
+ :visual => true,
+ :video => true,
+ :console => true
+ }
+
+ puts (caps)
+ # URL: https://{username}:{accessToken}@hub.lambdatest.com/wd/hub
+ @driver = Selenium::WebDriver.for(:remote,
+ :url => "https://"+username+":"+accessToken+"@"+gridUrl,
+ :desired_capabilities => caps)
+ end
+
+ def test_Login
+ """
+ Setup remote driver
+ Params
+ ----------
+ Execute test: navigate google.com search LambdaTest
+ Result
+ -------
+ print title
+ """
+ puts("Searching LambdaTest on google.com ")
+ sleep(15)
+ @driver.get("https://www.google.com/ncr")
+ elem = @driver.find_element(:name, 'q')
+ elem.send_keys("LambdaTest.com")
+ elem.submit()
+
+ puts("Printing title of current page :"+@driver.title)
+ end
+ def teardown
+ """
+ Quit selenium driver
+ """
+ @driver.quit
+ end
+end
+```
+
+Here’s how you can execute the test from your terminal.
+
+ ruby google-search-lambdatest.rb
+
+The first thing to note in this code is the use of remote webdriver. To access grid, you would have to invoke remote webdriver instead of local webdrivers. In addition, the browser enthronement details are passed on through desired_capabilities.
+
+In this example we are running a test on **Windows 10**, **Chrome 67 environment**. You can test your own choice of an environment by changing the parameters in the object. You can leverage our capabilities generator tool to create code for your environments.
+
+
+
+> **Tear Down**: The tear down method helps platform understand when the execution of a test is finished. It’s important to tear down each test or else it will give timeout errors.
diff --git a/docs/har-log-viewer-with-waterfall.mdx b/docs/har-log-viewer-with-waterfall.mdx
new file mode 100644
index 000000000..1547eeb28
--- /dev/null
+++ b/docs/har-log-viewer-with-waterfall.mdx
@@ -0,0 +1,38 @@
+---
+title: "HAR Log Viewer With Waterfall for Selenium Testing"
+sidebarTitle: "HAR Log Viewer With Waterfall"
+keywords: ['har log viewer with waterfall','har log viewer','har log viewer with waterfall lambdatest','har log viewer network logs','har log viewer with waterfall selenium']
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+***
+
+ Web Automation provides the HAR (HTTP Archive) Log Viewer with Waterfall that helps you analyze the performance of web pages for your Selenium automation tests.
+
+It provides a visual representation of how resources on a webpage are loaded and interact over time. The key component of this feature is the "waterfall" view, which graphically displays the sequence and duration of requests as a web page loads.
+
+## How to Use HAR Log Viewer With Waterfall on ?
+***
+
+To get the network logs using HAR Log Viewer With Waterfall, you need to pass `network.full.har = true` in your test scripts.
+
+Once you run the tests, navigate to the Web Automation Dashboard to see the HAR Log Viewer With Waterfall in action.
+
+
+
+In the above view, each resource (like an HTML file, a CSS stylesheet, JavaScript file, or an image) is represented as a horizontal bar. The length of the bar indicates the time taken to load that resource. The sequence in which these bars are arranged reflects the order in which the browser requested these resources. This graphical representation allows developers and testers to quickly identify bottlenecks or performance issues in the page loading process.
+
+## Use Cases for HAR Log Viewer With Waterfall
+***
+
+- **Performance Optimization**: By analyzing the waterfall chart, developers can pinpoint resources that take longer to load and optimize them. This might involve compressing images, minifying CSS and JavaScript files, or implementing better caching strategies.
+- **Diagnosing Load Order Issues**: Sometimes, the order in which resources load can impact the performance. Developers can use the HAR viewer to rearrange the loading sequence for efficiency, like ensuring critical CSS and JavaScript load first.
+- **Network Issues Identification**: Slow loading times can also be due to network issues. The HAR Log Viewer can help identify if the delay is server-side (long time to first byte) or network-related (slow download time).
+- **Performance Monitoring Over Time**: By regularly analyzing HAR logs, teams can monitor the performance of their web pages over time. This is crucial for detecting performance degradation or improvements following updates or changes to the site.
+- **Third-Party Resource Management**: Many websites rely on third-party resources (like ads, analytics scripts, etc.). The HAR viewer helps in identifying the impact of these resources on overall page load time and optimizing their loading strategy.
+- **Comparative Analysis**: By comparing HAR files before and after optimization efforts, developers can quantitatively measure the effectiveness of their changes in reducing load times and improving user experience.
+- **Understanding Browser Behavior**: Different browsers can behave differently in terms of resource loading. By analyzing HAR files from different browsers, developers can understand these nuances and optimize for cross-browser compatibility.
+- **Compliance and Testing**: Ensuring that a site loads efficiently under various conditions (like slow network speeds) is essential for compliance with web performance standards. HAR logs can be used to test and ensure compliance under these scenarios.
+
+
diff --git a/docs/har_log-viewer.mdx b/docs/har_log-viewer.mdx
new file mode 100644
index 000000000..cb321ca8c
--- /dev/null
+++ b/docs/har_log-viewer.mdx
@@ -0,0 +1,38 @@
+---
+title: "HAR Log Viewer With Waterfall for Selenium Testing"
+sidebarTitle: "Inspect HAR Logs"
+description: "Learn how to use HAR Log Viewer With Waterfall for Selenium automation testing on TestMu AI."
+keywords: ['har log viewer with waterfall', 'har log viewer', 'har log viewer with waterfall testmu ai', 'har log viewer network logs', 'har log viewer with waterfall selenium']
+"og:description": "Learn how to use HAR Log Viewer With Waterfall for Selenium automation testing on TestMu AI."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+ Web Automation provides the HAR (HTTP Archive) Log Viewer with Waterfall that helps you analyze the performance of web pages for your Selenium automation tests.
+
+It provides a visual representation of how resources on a webpage are loaded and interact over time. The key component of this feature is the "waterfall" view, which graphically displays the sequence and duration of requests as a web page loads.
+
+## How to Use HAR Log Viewer With Waterfall on ?
+***
+
+To get the network logs using HAR Log Viewer With Waterfall, you need to pass `network.full.har = true` in your test scripts.
+
+Once you run the tests, navigate to the Web Automation Dashboard to see the HAR Log Viewer With Waterfall in action.
+
+
+
+In the above view, each resource (like an HTML file, a CSS stylesheet, JavaScript file, or an image) is represented as a horizontal bar. The length of the bar indicates the time taken to load that resource. The sequence in which these bars are arranged reflects the order in which the browser requested these resources. This graphical representation allows developers and testers to quickly identify bottlenecks or performance issues in the page loading process.
+
+## Use Cases for HAR Log Viewer With Waterfall
+***
+
+- **Performance Optimization**: By analyzing the waterfall chart, developers can pinpoint resources that take longer to load and optimize them. This might involve compressing images, minifying CSS and JavaScript files, or implementing better caching strategies.
+- **Diagnosing Load Order Issues**: Sometimes, the order in which resources load can impact the performance. Developers can use the HAR viewer to rearrange the loading sequence for efficiency, like ensuring critical CSS and JavaScript load first.
+- **Network Issues Identification**: Slow loading times can also be due to network issues. The HAR Log Viewer can help identify if the delay is server-side (long time to first byte) or network-related (slow download time).
+- **Performance Monitoring Over Time**: By regularly analyzing HAR logs, teams can monitor the performance of their web pages over time. This is crucial for detecting performance degradation or improvements following updates or changes to the site.
+- **Third-Party Resource Management**: Many websites rely on third-party resources (like ads, analytics scripts, etc.). The HAR viewer helps in identifying the impact of these resources on overall page load time and optimizing their loading strategy.
+- **Comparative Analysis**: By comparing HAR files before and after optimization efforts, developers can quantitatively measure the effectiveness of their changes in reducing load times and improving user experience.
+- **Understanding Browser Behavior**: Different browsers can behave differently in terms of resource loading. By analyzing HAR files from different browsers, developers can understand these nuances and optimize for cross-browser compatibility.
+- **Compliance and Testing**: Ensuring that a site loads efficiently under various conditions (like slow network speeds) is essential for compliance with web performance standards. HAR logs can be used to test and ensure compliance under these scenarios.
diff --git a/docs/he-integration-with-testmu-products.mdx b/docs/he-integration-with-testmu-products.mdx
new file mode 100644
index 000000000..a1159fe56
--- /dev/null
+++ b/docs/he-integration-with-testmu-products.mdx
@@ -0,0 +1,32 @@
+---
+title: "HyperExecute Integrations with Products"
+sidebarTitle: Integration With TestMu AI Products
+keywords: ['TestMu AI Hyperexecute','TestMu AI Hyperexecute help','TestMu AI Hyperexecute documentation','Integrations','Products']
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+You can now integrate HyperExecute with other products like Smart UI testing. You can go through the links below to see the integrations we offer at the moment.
+
+
+
+
+
+ Execute Smart UI Tests to ensure the visual consistency of web applications using HyperExecute.
+
+
+ Execute Smart UI Tests using SDK to ensure the visual consistency of web applications using HyperExecute.
+
+
+ Run app automated tests on Emulators and Simulators using HyperExecute.
+
+
+ Run app automated tests on Real Mobile Devices using HyperExecute..
+
+
+
+
+If your favourite products are not mentioned in the list above, then just give us a window.openLTChatWidget()}>shout and we will have them ready for you.
+
+
diff --git a/docs/hive-integration.mdx b/docs/hive-integration.mdx
new file mode 100644
index 000000000..f774b7a44
--- /dev/null
+++ b/docs/hive-integration.mdx
@@ -0,0 +1,121 @@
+---
+title: "Hive Integration"
+sidebarTitle: "Hive"
+description: "TestMu AI helps you to push bugs directly in Hive project with details like work space, assignee, title and description with a single click."
+keywords: ['testmu ai integrations', 'push issues to hive', 'free cross browser testing tool', 'cross platform testing tools', 'check browser compatibility online', 'testmu ai hive integration', 'integrate hive with testmu ai', 'create issue in hive from testmu ai', 'hive integration with testmu ai', 'create jira issues from hive', 'bug tracking tools', 'project management tools']
+"og:description": "TestMu AI helps you to push bugs directly in Hive project with details like work space, assignee, title and description with a single click."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Hive is an online project management application that aims at maximizing your workplace productivity. With Hive you can plan project flexible and organize them in a Gantt chart, kanban board, table, or calendar. You can also keep a check on multiple projects simultaneously using their views and they also offer summary views to help you combine several projects in a single space, so you can visualize where all the teams are headed. integration with Hive helps to manage your bugs in Hive by moving them into a project through a single click effort. All the details you provide in like task list, assignee, title and description would automatically be presented in the project on Hive.
+
+The Hive integration helps you in filing issues to your project in Hive directly from platform. With one-click integration, you can push annotated issues to the project of your choice, assign it to the required teammate, and attach necessary screenshots. You can do all that while in the middle of a test session in platform. The fields populated by you when marking as a bug through are displayed as information on the Hive for a testing instance.
+
+
+Hive Integration with , like all of the integrations to 3rd party applications, is available for freemium as well as premium plan.
+
+
+## How To Establish Integration With Hive From Your Account?
+***
+**Step 1:** Login to your account. You would need to have Admin or User level access to see and install integrations.
+
+**Step 2:** Select ‘Integrations’ 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 **‘Hive’**.
+
+
+
+**Step 4:** Once you click on install, you will be redirected to the below screen. You will be asked to provide your Hive User ID and your Hive API Key credentials in the highlighted fields to establish integration with .
+
+
+
+
+**What is an API key?**
+
+When two different applications interact with each other, a server-to-server communication is established. API key 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 key 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 keys are relevant if an end user logs in an application through a 2-step verification process.
+
+**Step 5:** You can find your Hive User ID & API key from your Hive workspace. Click the display picture on the top right and go to **Edit profile**.
+
+
+
+**Step 6:** Click **API info** from the left menu.
+
+
+
+**Step 7**: Copy your **API Key** and **User ID**.
+
+
+
+
+You can keep a note of this API key with you for future authentication. Although, in case you forget to do so, or you end up neglecting it due to some reason. Then there is no need to panic! You can always regenerate the key.
+
+
+**Step 8:** Paste the copied strings on the field provided at & hit the ‘Next’ button and you are all set to experience one-click bug logging to share your issues directly from your account to your project on Hive.
+
+
+
+That’s it! Go to Integrations again and you will be able to notice a green tick indicating that Hive is successfully installed.
+
+
+
+## How To Log Your First Bug Through Hive Integration?
+***
+**Step 1:** Go for any of the test from the left navigation menu. For demo, we will be taking "Real Time Test" option.
+
+**Step 2:** Present a URL of the web-app you need to test in the dialog box. After that, select any configuration for browser and operating system of your choice & hit ‘Start‘.
+
+
+
+**Step 3:** After the VM is launched and operable. You can perform testing on your web-app for finding bugs. If a bug gets revealed, then you need to click on the Bug icon from the left panel for [capturing a screenshot](https://www.lambdatest.com/full-page-screen-capture) of the same. We have highlighted that controller button in the below image.
+
+
+
+**Step 4:** After a screenshot is captured, you can annotate any issue or a task with an in-built image editor. Once you are done highlighting the bug, click on the button that says "Mark as Bug".
+
+
+
+**Step 5:** After clicking on "Mark as Bug" button a Hive specific form would open up. Fill the fields as per your requirement.
+
+---
+
+* You can set the relevant Workspaces for your UI observation.
+* You can select which project should the task go under.
+* You can assign the bug to a colleague by populating the field ‘Assignee‘.
+* You can mention the Title as well to easily organize your bugs.
+* You also get to post a description to help relate the cause of the issue or the task.
+---
+
+
+
+**Step 6:** Click on "Create Bug" & observe it being successfully marked through a single click effort. Once you hit the button, you will get prompt messages on top of your Virtual Machine indicating the progress of bug logging. You will get a prompt message in few seconds mentioning **"Bug successfully marked"** indicating that the issue has been successfully pushed to the respective workspace.
+
+
+
+**Step 7:** Visit your Hive dashboard. You will be able to notice the logged issue right away by going to the particular project and task list you assigned it to!
+
+
+
+As you click on the task you will notice that all the data you provided through would already be presented in it. automatically includes test environment details and related screenshots in the task as attachments.
+
+
+
+## How To Uninstall Hive Integration?
+***
+
+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 `uninstall` your current integration. Here is how you can do that.
+
+
+**Step 1:** Login to your account.
+
+**Step 2:** Select ‘Integration’ from the left navigation menu bar. 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 ‘Hive’ block which would be highlighted with a green tick.
+
+
+
+
+That was all you need to know for + Hive 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!
+
diff --git a/docs/how-to-set-the-open-file-limit-while-using-tunnel.mdx b/docs/how-to-set-the-open-file-limit-while-using-tunnel.mdx
new file mode 100644
index 000000000..2f5bec1fd
--- /dev/null
+++ b/docs/how-to-set-the-open-file-limit-while-using-tunnel.mdx
@@ -0,0 +1,54 @@
+---
+title: "How To Set The Open File Limit While Using TestMu AI Tunnel?"
+sidebarTitle: "Setting The Open File Limit While Using TestMu AI Tunnel"
+keywords: ["proxy settings", "set open file limit", "open file limit lambdatest", "lambdatest proxy settings", "lambdatest proxy profile"]
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+If you are using a tunnel service with for cross browser testing then you may get the following warning.
+
+*File descriptor limit is too low! Increase your limit to at least 2000.*
+
+This warning is sent across to help you avoid a lack of available file handles. If this warning is ignored for a long time then you might have issues connecting your tunnel with . This would also be reflected in the logs if you fail to connect your tunnel with . The logs would be reflecting the below error message.
+
+*accept tcp 127.0.0.1:9090: accept: too many open files.*
+
+We recommend that you expand the open file limit to 2000 for a seamless browser testing experience.
+
+## How To Expand The Open File Limit Using macOS/Linux?
+---
+You can increase the open file limit either temporarily or permanently for your profile. In case of temporary modification, your profile settings will be restored once the terminal is shut down.
+
+### Increasing The Open File Limit Temporarily
+---
+**Step 1**: Gain Sudo rights and run the below command to set the open file limit to 2000.
+
+`ulimit -SHn 2000`
+
+
+
+
+NOTE
+
+Note: If your system is capable of handling a higher limit then please feel free to set the limit above 2000. However, 2000 is the minimum recommendation.
+
+
+**Step 2**: Next, we need to verify if the setting are modified by running the below command.
+
+`ulimit -n`
+
+**Step 3**: Restart the tunnel and you’re ready to go!
+
+### Increasing The Open File Limit Permanently
+---
+**Step 1**: You would have to edit the profile settings and set the file limit in the your `.profile` or `.bashrc` file. Add the below command in your `.profile` or `.bashrc` file.
+
+`ulimit -SHn 2000`
+
+**Step 2**: Execute `source ~/.bash_profile` or `.bashrc` or the profile you're using.
+
+**Step 3**: Run the command `ulimit -n` to verify if the setting are modified.
+
+**Step 4**: Restart the tunnel and you're ready to go!
diff --git a/docs/how-to-use-in-session-testing-tools.mdx b/docs/how-to-use-in-session-testing-tools.mdx
new file mode 100644
index 000000000..518330877
--- /dev/null
+++ b/docs/how-to-use-in-session-testing-tools.mdx
@@ -0,0 +1,156 @@
+---
+title: How to use in-session testing tools?
+
+sidebarTitle: "Use In-Session Tools"
+description: "With TestMu AI, perform live interactive testing of websites and web applications on real Android and iOS devices to ensure seamless user experience."
+
+keywords: ['real device app testing', 'real device browser testing', 'mobile app testing', 'app automation']
+"og:description": "With TestMu AI, perform live interactive testing of websites and web applications on real Android and iOS devices to ensure seamless user experience."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+With ’s Real Device browser testing, you get access to a plethora of features that helps QA ease their real device browser testing process, without the need of leaving the instance window. From features such as mark as bug and changing IP geolocation, to in-depth Chrome DevTools and Safari Web Inspector, 's Real Device browser testing offers it all.
+
+Let us get an overview of all the features in our real device instance:
+
+## Comprehensive Sidebar
+
+
+
+### Home
+
+The **Home** feature on the left-sidebar allows you to go to the home screen of your selected real device instantly.
+
+### Screenshot
+
+The **Screenshot** feature allows you to take a screenshot in an instant of the current screen of the device that you are currently testing on. You can access the screenshots and even download them in the gallery section.
+
+### Record Session
+
+The **Record Session** feature allows you to screen record the current test session inside the real device. As you click on the button a timer would start, indicating the recording time. You can click on the stop button to stop the video recording.
+
+Just as your screenshots, you can find your recorded video in the gallery. You can also download the recording by clicking on the download button.
+
+
+
+### Mark As Bug
+
+The **Mark as Bug** feature allows you to push your UI related issues/edited screenshot to your integrated workspace instantly.
+
+
+
+### Gallery
+
+All screenshots and video recordings from test sessions are stored in the Gallery. To access, select **Gallery** from the left toolbar and you'll find the saved screenshots and videos.To download the screenshots or videos to your local machine, click on the Download icon.
+
+
+
+### IP Geolocation
+
+The **IP Geolocation** feature allows you to emulate website and mobile experiences from more than 45 countries using local IP addresses. This enables you to test localized elements like pricing, languages, and product offerings. With IP Geolocation activated, you can verify that your app's traffic is coming from a particular country, facilitating thorough global testing.
+
+
+
+Check out our detailed support documentation to know more about the [IP Geolocation](/support/docs/list-of-supported-locales/) feature.
+
+### GPS Location
+
+**GPS Geolocation** testing allows you to simulate specific device locations using exact GPS coordinates to evaluate location-based app scenarios. You can enter your preferred location by entering the name of the location.
+
+However, if your preferred location is not showing, you can specify the exact location by entering the lattitude and longitude of the location.
+
+
+
+### Network Throttling
+
+With ’s **Network Throttling**, you can test mobile applications across a range of network conditions, including offline, as well as specific network profiles like 3G, 3G+, 4G LTE, 4G Advanced and even custom network profile with its extensive real mobile device cloud.
+
+You can simulate these network environments using either pre-defined profiles or by creating custom network profiles to suit your needs.
+
+
+
+Check out our detailed support documentation to know more about the [Network Throttling](/support/docs/app-auto-network-throttling/) feature.
+
+### iOS Settings
+
+With the **iOS settings**, you can enable the Accessibility Testing. It focuses on ensuring that applications and web content are usable by individuals with different abilities. Learn in detailed way about [Accessibility in iOS devices.](/support/docs/accessibility-settings-ios)
+
+
+
+### Device Controls
+
+With the **Device Controls** feature, you can easily manage various settings on your device, such as adjusting the volume and changing its orientation.
+
+Under Device Control, you'll find multiple options to customize your device's settings:
+
+1. **Volume**: Adjust the device's volume to your preferred level.
+2. **Rotate**: Change the screen orientation between landscape and portrait modes.
+3. **Recent Apps** : Available on `iOS 15` and above, this feature allows you to view recent apps. Note that it is not supported on devices that rely on a physical button for accessing recent apps instead of the swipe-up gesture.
+4. **Bluetooth**: Used to enable the bluetooth functionality during the session.
+
+
+
+### Settings
+
+The **settings** section offer the following features:
+
+- **Idle Timeout:** This feature allows you to set the idle timeout for your test session by selecting from the dropdown menu. The default Idle Timeout is 5 minutes and the maximum limit is 45 minutes.
+- **Time Zone:** With this feature, you can select the time zone of your preference from the dropdown menu. The time zone are set to GMT by default and can be changed as per preference.
+- **Language:** With this feature, you can change the language in your test session for a more localized testing experience. Language locale doc.
+- **Projects:** The projects feature allows you to track your existing test session in an existing project. You can create and access your projects under **More Tools**.
+
+
+
+### Switch
+
+This feature allows you to **switch** between devices, browser and their OS versions without exiting your current test session.
+
+
+
+### End Session
+
+By clicking on the end session button, you can close your current test session.
+
+## Comprehensive Top Bar
+***
+
+
+
+### Zoom In-Out
+
+With the zoom in-out slider, you can zoom in and out in your real device as per your preference.
+
+### Chrome DevTools
+
+’s real device browser testing offers in-built developer tools to help QA debug their websites and web applications.
+
+
+
+### Safari Web Inspector
+
+’s real device browser testing offers in-built **Safari Web Inspector**, an open-source web development tool to simplify optimizing, prototyping, and debugging web applications for iOS and OS X.
+
+
+
+### Test Manager
+
+Unified **Test Manager** simplifies test authoring, management, triggering, and reporting, boosting efficiency throughout all testing phases.
+
+
+
+
+**Notes:** The max duration for running manual tests on Real Device Cloud is 2 hours. In order to extend the duration, you can opt for our dedicated real device cloud.
+
diff --git a/docs/how-to-use-testing-tools-in-session.mdx b/docs/how-to-use-testing-tools-in-session.mdx
new file mode 100644
index 000000000..bd8ac16b1
--- /dev/null
+++ b/docs/how-to-use-testing-tools-in-session.mdx
@@ -0,0 +1,190 @@
+---
+title: "How to use testing tools in-session?"
+sidebarTitle: "Use In-Session Tools"
+description: "Mobile app testing is the process of testing a mobile application to ensure that their functionality and usability is not compromised when installed across multiple Android and iOS devices. With TestMu AI, you can test mobile applications manually to ensure they perform seamlessly across all Android and iOS real devices."
+keywords: ['real device app testing', 'real device browser testing', 'mobile app testing', 'app automation']
+"og:description": "Mobile app testing is the process of testing a mobile application to ensure that their functionality and usability is not compromised when installed across multiple Android and iOS devices. With TestMu AI, you can test mobile applications manually to ensure they perform seamlessly across all Android and iOS real devices."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+With Real Device App Testing, you get access to a plethora of features that helps QA ease their app testing process, without the need of leaving the instance window. From mark as bug and changing IP geolocation, to in-depth device logs and network logs, 's real device app testing offers it all.
+
+Let us get an overview of all the features in our real device instance:
+
+## Comprehensive Sidebar
+***
+
+
+
+### Home
+
+The **Home** feature on the left-sidebar allows you to go to the home screen of your selected real device instantly.
+
+### App Controls
+
+The **App Control** feature offers you the ability to perform actions with your installed application within your current test session. This feature offers a dropdown with options such as:
+
+- **Install New App:** By selecting this option you can quickly install multiple applications in your already running test session, without having to quit and start a new session. Without any installation limit.
+- **Kill App:** By selecting this option, you can easily kill all your installed applications.
+- **Uninstall App:** By selecting this option, you can easily uninstall all the installed applications.
+
+
+
+### Screenshot
+
+The **Screenshot** feature allows you to take a screenshot of the current screen of the device that you are currently testing on. You can access the screenshots and even download them in the gallery section.
+
+### Record Session
+
+The **Record Session** feature allows you to screen record the current test session inside the real device. As you click on the button a timer would start running to indicate the recording time. You can click on the stop button to stop the video recording.
+
+Just as your screenshots, you can find your recorded video in the gallery. You can also download the recording by clicking on the download button.
+
+
+
+### Mark As Bug
+
+The **Mark as Bug** feature allows you to push your UI related issues/edited screenshot to your integrated workspace instantly.
+
+
+
+### Gallery
+
+All screenshots and video recordings from test sessions are stored in the Gallery. To access, select **Gallery** from the left toolbar and you'll find the saved screenshots and videos.To download the screenshots or videos to your local machine, click on the Download icon.
+
+
+
+### IP Geolocation
+
+The **IP Geolocation** feature allows you to emulate website and mobile experiences from more than 45 countries using local IP addresses. This enables you to test localized elements like pricing, languages, and product offerings. With IP Geolocation activated, you can verify that your app's traffic is coming from a particular country, facilitating thorough global testing.
+
+
+
+Check out our detailed support documentation to know more about the [IP Geolocation](/support/docs/list-of-supported-locales/) feature.
+
+### GPS Location
+
+**GPS Geolocation** testing allows you to simulate specific device locations using exact GPS coordinates to evaluate location-based app scenarios. You can enter your preferred location by entering the name of the location.
+
+However, if your preferred location is not showing, you can specify the exact location by entering the lattitude and longitude of the location.
+
+
+
+### Network Throttling
+
+With ’s **Network Throttling**, you can test mobile applications across a range of network conditions, including offline, as well as specific network profiles like 3G, 3G+, 4G LTE, 4G Advanced and even custom network profile with its extensive real mobile device cloud.
+
+You can simulate these network environments using either pre-defined profiles or by creating custom network profiles to suit your needs.
+
+
+
+Check out our detailed support documentation to know more about the [Network Throttling](/support/docs/app-auto-network-throttling/) feature.
+
+### Files Upload
+
+Real device app testing on comes with preloaded media files on remote devices for testing scenarios that need file access. Additionally, you have the option to upload your own media or non-media files to cover your testing scenarios. You can upload files with formats: JPEG, PNG, MP4, 3GP, PDF, CSV, DOC and other major formats.
+
+
+
+Check out our detailed support documentation to know more about the [Files Upload](/support/docs/upload-media/) feature.
+
+### iOS Settings
+
+With the **iOS settings**, you can access the crash logs as well as the app settings. For crash logs, If the app crashes at any point, the crash log gets downloaded automatically. Application settings allows you to access the default application settings in your iOS devices.
+
+
+
+- **Crash Logs :** You can download your crashed logs of the application.
+- **App Settings :** This will open the settings of the application in your mobile device.
+- **Accessibility :** Accessibility testing on iOS devices focuses on ensuring that applications and web content are usable by individuals with different abilities. Learn in detailed way about [Accessibility in iOS devices.](/support/docs/accessibility-settings-ios)
+
+- **Select Date and Time :** Opens a modal where you can:
+ - Toggle **Set Automatically** to sync with network time.
+ - Manually select a **Date** (up to 7 days ahead).
+ - Enter a **Time** in **HH:MM:SS** format.
+ - Choose between **12-hour** or **24-hour** time formats.
+ - Once configured, click **Update** to apply the changes to the device.
+
+### Device Controls
+
+With the **Device Controls** feature, you can easily manage various settings on your device, such as adjusting the volume and changing its orientation.
+
+Under Device Control, you'll find multiple options to customize your device's settings:
+
+1. **Volume**: Adjust the device's volume to your preferred level.
+2. **Rotate**: Change the screen orientation between landscape and portrait modes.
+3. **Recent Apps** : Available on `iOS 15` and above, this feature allows you to view recent apps. Note that it is not supported on devices that rely on a physical button for accessing recent apps instead of the swipe-up gesture.
+4. **Bluetooth**: Used to enable the bluetooth functionality during the session.
+
+
+
+### Settings
+
+The settings section offer the following features:
+
+- **Idle Timeout:** This feature allows you to set the idle timeout for your test session by selecting from the dropdown menu. The default Idle Timeout is 5 minutes and the maximum limit is 45 minutes.
+- **Time Zone:** With this feature, you can select the time zone of your preference from the dropdown menu. The time zone are set to GMT by default and can be changed as per preference.
+- **Language:** With this feature, you can change the language in your test session for a more localized testing experience. Language locale doc.
+- **Projects:** The projects feature allows you to track your existing test session in an existing project. You can create and access your projects under **More Tools**.
+
+
+
+### Switch
+
+This feature allows you to **switch** between devices, browser and their OS versions without exiting your current test session.
+
+
+
+### End Session
+
+By clicking on the end session button, you can close your current test session.
+
+## Comprehensive Top Bar
+***
+
+
+
+### Zoom In-Out
+
+With the **zoom in-out** slider, you can zoom in and out in your real device as per your preference.
+
+### Network Logs
+
+**Network Logs** record performance metrics including network traffic, latency, and HTTP requests and responses in the HAR (HTTP Archive) format. These logs provide a detailed overview of all network requests, such as REST API calls, from your app and their response times, aiding in the identification of performance bottlenecks and troubleshooting of failed REST API responses.
+
+
+
+### Device Logs
+
+**Device logs** are application-specific system logs generated by iOS or Android that provide access to your application's logs. They are particularly useful for analyzing issues when the application crashes during testing.
+
+
+
+### UI Inspector
+
+The Intelligent **UI Inspector** for real device testing streamlines mobile app testing by enabling direct interaction with devices, allowing testers to efficiently inspect app elements without the need of repeatedly opening and closing the inspector. The Intelligent UI Inspector offers the capability to crеatе custom XPaths еffortlеssly for automation test scripts.
+
+
+
+### Test Manager
+
+Unified **Test Manager** simplifies test authoring, management, triggering, and reporting, boosting efficiency throughout all testing phases.
+
+
+
+
+**Notes:** The max duration for running manual tests on Real Device Cloud is 2 hours. In order to extend the duration, you can opt for our dedicated real device cloud.
+
diff --git a/docs/html-dom-smartui-options.mdx b/docs/html-dom-smartui-options.mdx
new file mode 100644
index 000000000..d0d760992
--- /dev/null
+++ b/docs/html-dom-smartui-options.mdx
@@ -0,0 +1,315 @@
+---
+title: "Handling Dynamic Data with DOM Configuration and Options for SmartUI"
+sidebarTitle: "Handling Dynamic Data"
+description: "In this documentation, learn how to handle dynamic content of your web pages for visual regression."
+keywords: ['Visual Regression', 'Visual Regression Testing Guide', 'Visual Regression Test Automation', 'Visual Regression Automation Testing', 'Running Visual Regression Tests', 'Visual Regression Testing Online', 'Run Visual Regression', 'Visual Regression Run Specific Test', 'Visual Regression Testing Environment', 'How to Run Visual Regression Tests']
+"og:description": "In this documentation, learn how to handle dynamic content of your web pages for visual regression."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+import { NewTag } from "/snippets/NewTag.mdx";
+
+
+---
+
+
+Using the platform, perform regression testing in just one click and explore various possible solutions for grouping your screenshots into different builds and map as per your testing suite needs.
+
+In case if you have any dynamic elements that are not in the same position across test runs, you can ignore / select a specific area to be removed from the comparison.
+
+## Configuration for Selenium
+
+The following are the different options which are currently supported:
+
+| Key | Description |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `screenshotName` (string) | Specify a name for the screenshot in your tests to match the same screenshot with the name from your baseline |
+| `fullPage` (boolean) | Specify `true` if you want to take a Full Page Screenshot and `false` for viewport screenshots; `fullPage: true` is currently only supported for `Chrome` |
+| `ignoreDOM` (object) **** | Specify one or a combination of selectors based on the `HTML DOM ID, CSS class, CSS selector or Xpath` used by your webpage that should be excluded from the comparison |
+| `selectDOM` (object) | Specify one or a combination of selectors based on the `HTML DOM ID, CSS class, CSS selector or XPath` used by your webpage that should be included in the comparison |
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to ignore by ID"
+let config = {
+ screenshotName: "Ignore-ID",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ ignoreDOM: {
+ id: ["ID-1", "ID-2"], // Ignoring elements by ID, you can ignore multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to ignore by Class"
+let config = {
+ screenshotName: "Ignore-Class",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ ignoreDOM: {
+ class: ["Class-1", "Class-2"], // Ignoring elements by class, you can ignore multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to ignore by XPath"
+let config = {
+ screenshotName: "Ignore-XPath",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ ignoreDOM: {
+ xpath: ["Xpath-1", "Xpath-2"], // Ignoring elements by XPath, you can ignore multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to ignore by CSS Selector"
+let config = {
+ screenshotName: "Ignore-cssSelector",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ ignoreDOM: {
+ cssSelector: ["CSS-Selector-1", "CSS-Selector-2"], // Ignoring elements by CSS selector, you can ignore multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to select by ID."
+let config = {
+ screenshotName: "Select-ID",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ selectDOM: {
+ id: ["ID-1", "ID-2"], // Selecting elements by ID, you can select multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to select by Class"
+let config = {
+ screenshotName: "Select-Class",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ selectDOM: {
+ class: ["Class-1", "Class-2"], // Selecting elements by class, you can select multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to select by XPath"
+let config = {
+ screenshotName: "Select-XPath",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ selectDOM: {
+ xpath: ["Xpath-1", "Xpath-2"], // Selecting elements by XPath, you can select multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+
+```js title="This is a sample for your webhook configuration for JavaScript to select by CSS Selector"
+let config = {
+ screenshotName: "Select-cssSelector",
+ fullPage: false, //You can make this property as true in case of Chrome browser
+ selectDOM: {
+ cssSelector: ["CSS-Selector-1", "CSS-Selector-2"], // Selecting elements by CSS selector, you can select multiple at once
+ },
+};
+await driver.executeScript("smartui.takeScreenshot", config);
+```
+
+
+
+
+## Configuration for Puppeteer
+
+The following are the different options which are currently supported:
+
+| Key | Description |
+| ------------------------- | --------------------------------------- |
+| `screenshotName` (string) | Specify a name for the screenshot in your tests to match the same screenshot with the name from your baseline |
+| `ignoreDOM` (object) | Specify a selector based on the HTML DOM ID, CSS class or CSS selector used by your webpage that should be excluded from the comparison |
+| `selectDOM` (object) | Specify a selector based on the HTML DOM ID, CSS class or CSS selector used by your webpage that should be included in the comparison |
+| `ignoreXPath` (object) | Specify a selector based on theXPath of the element that should be excluded from the comparison |
+| `selectXPath` (object) | Specify a selector based on theXPath of the element that should be included in the comparison |
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreDOM : {id:["HTML DOM Id"]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreDOM : {class:[""]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreXPath: ['Xpath-1', 'Xpath-2']} })}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreDOM : {cssSelector:[""]} }})}`)
+```
+
+
+
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectDOM : {id:["HTML DOM Id"]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectDOM : {class:[""]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectXPath: ['Xpath-1', 'Xpath-2']} })}`)
+```
+
+
+
+
+
+```js title="This is a sample for your webhook configuration for Puppeteer"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectDOM : {cssSelector:[""]} }})}`)
+```
+
+
+
+
+## Configuration for Playwright
+
+The following are the different options which are currently supported:
+
+| Key | Description |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `screenshotName` (string) | Specify a name for the screenshot in your tests to match the same screenshot with the name from your baseline |
+| `ignoreDOM` (object) | Specify a selector based on the HTML DOM ID, CSS class or CSS selector used by your webpage that should be excluded from the comparison |
+| `selectDOM` (object) | Specify a selector based on the HTML DOM ID, CSS class or CSS selector used by your webpage that should be included in the comparison |
+| `ignoreXPath` (object) | Specify a selector based on theXPath of the element that should be excluded from the comparison |
+| `selectXPath` (object) | Specify a selector based on theXPath of the element that should be included in the comparison |
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreDOM : {id:["HTML DOM Id"]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreDOM : {class:[""]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreXPath: ['Xpath-1', 'Xpath-2']} })}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', ignoreDOM : {cssSelector:[""]} }})}`)
+```
+
+
+
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectDOM : {id:["HTML DOM Id"]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectDOM : {class:[""]} }})}`)
+```
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectXPath: ['Xpath-1', 'Xpath-2']} })}`)
+```
+
+
+
+
+
+```js title="This is a sample for your webhook configuration for Playwright"
+await page.evaluate((_) => {},
+ `lambdatest_action: ${JSON.stringify({ action: 'smartui.takeScreenshot', arguments: { fullPage: false, screenshotName: 'dom-screenshot', selectDOM : {cssSelector:[""]} }})}`)
+```
+
+
+
diff --git a/docs/http-basic-authentication.mdx b/docs/http-basic-authentication.mdx
new file mode 100644
index 000000000..af061e3a4
--- /dev/null
+++ b/docs/http-basic-authentication.mdx
@@ -0,0 +1,29 @@
+---
+title: "HTTP Basic Authentication"
+sidebarTitle: "Handle Basic Authentication"
+description: "HTTP basic authentication represents a mechanism of challenge and response to help the server make a request authentication from a client, passing the User ID and password in the URL as the standard HTTP "Authorization" header."
+keywords: ['http basic authentication', 'http authentication', 'basic authentication', 'http authorization header', 'browser support for http authentication']
+"og:description": "HTTP basic authentication represents a mechanism of challenge and response to help the server make a request authentication from a client, passing the User ID and password in the URL as the standard HTTP "Authorization" header."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+HTTP basic authentication represents a challenge and response mechanism to help the server make a request authentication from a client, passing the User ID and password in the URL as the standard HTTP "Authorization" header.
+
+For example: `https://username:password@www.example.com/example-page.php`
+
+## Browser Support For HTTP Basic Authentication
+
+* * *
+HTTP authentication is incompatible among the majority of the web browser. It is supported by only Google Chrome and Mozilla Firefox.
+
+| BROWSER | SUPPORT FOR BASIC HTTP AUTHENTICATION |
+| ------------ | --------------------------------------------------------------------------------------------------------------------------- |
+| Google Chrome | Supported |
+| Mozilla FireFox | Although supported, Mozilla Firefox may throw a prompt confirmation. Mozilla Firefox performs a check to evaluate whether basic HTTP authentication is mandatory to access the website. In cases, where it isn’t necessary, Firefox will throw a similar warning: "You are about to log in to the site "www.example.com" with the username "username", but the website does not require authentication. This may be an attempt to trick you." For more information, refer to the [MDN document](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). |
+| Safari | Unsupported |
+| Edge | Unsupported |
+| Internet Explorer | Supported |
diff --git a/docs/http2-support.mdx b/docs/http2-support.mdx
new file mode 100644
index 000000000..9313c4789
--- /dev/null
+++ b/docs/http2-support.mdx
@@ -0,0 +1,36 @@
+---
+title: "HTTP/2 Support in TestMu AI Tunnel"
+sidebarTitle: "HTTP/2 Support"
+description: "Learn how TestMu AI Tunnel supports HTTP/2 for modern, high-performance web application testing."
+
+keywords: ['http2', 'testmu ai tunnel', 'performance testing', 'web protocol', 'automatic proxy']
+"og:description": "Learn how TestMu AI Tunnel supports HTTP/2 for modern, high-performance web application testing."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+## Overview
+
+ Tunnel provides out-of-the-box support for HTTP/2, enabling users to test their web applications using the latest web protocol without any additional configuration. HTTP/2 support is essential for performance testing, as it includes improvements such as multiplexing, server push, and header compression. This document provides an overview of HTTP/2 support within Tunnel and its benefits.
+
+## Key Features
+
+- **Automatic HTTP/2 Proxying:** Tunnel automatically proxies both HTTP/1 and HTTP/2 traffic, simplifying the testing process for applications that use the latest web protocols.
+- **Improved Performance Testing:** With HTTP/2 support, users can test their applications' performance characteristics, such as load times and response behavior, under conditions that mirror modern browser-server communication.
+- **Seamless Integration:** No additional flags or configurations are required to enable HTTP/2 support, ensuring a smooth integration into existing testing workflows.
+
+## Usage
+
+Using HTTP/2 with Tunnel does not require any special configuration or flags. The tunnel automatically detects and proxies HTTP/2 traffic alongside HTTP/1, ensuring that your tests accurately reflect the behavior of web applications under real-world conditions.
+
+To start using Tunnel with HTTP/2 support, simply initiate the tunnel as you normally would:
+
+```sh
+./LambdaTestTunnel --user YourLambdaTestUsername --key YourLambdaTestAccessKey
+```
+
+With the tunnel running, any HTTP/2 traffic between your local development environment and the cloud platform will be automatically proxied, allowing you to conduct thorough performance and functionality testing on your web applications.
+
+## Conclusion
+
+The inherent support for HTTP/2 in Tunnel is a testament to 's commitment to providing developers and QA professionals with cutting-edge tools for web application testing. By automating the proxying of HTTP/2 traffic, Tunnel ensures that users can effortlessly test their applications in environments that utilize the latest web protocols, leading to faster, more reliable web applications.
diff --git a/docs/hyperexecute-accelq-integration.mdx b/docs/hyperexecute-accelq-integration.mdx
new file mode 100644
index 000000000..7a42e0919
--- /dev/null
+++ b/docs/hyperexecute-accelq-integration.mdx
@@ -0,0 +1,248 @@
+---
+title: "Accelq Integration with HyperExecute"
+sidebarTitle: "Run ACCELQ Tests"
+description: "Leverage TestMu AI's cloud mobile devices to run automation testing using Accelq Studio."
+keywords: ['accelq studio', 'integraion', 'automation easy', 'no code automation', 'no code mobile automation', 'gui based mobile automation', 'real devices']
+"og:description": "Leverage TestMu AI's cloud mobile devices to run automation testing using Accelq Studio."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+ACCELQ is a cloud-based, continuous testing platform for functional and API testing needs. It is a codeless test automation tool that allows users to create and execute tests without writing any code. ACCELQ uses a natural language abstraction to generate Java code, which makes it easy to learn and use.
+
+## Integrate Accleq with HyperExecute
+***
+Accelq is the most powerful software testing tool to achieve Codeless test automation and accelerate continuous testing.
+
+### Prerequisites
+---
+- Sample scripts in Accelq
+- Ensure that you have integrated [Accelq with ](/support/docs/accelq-integration/) Cloud Selenium Grid
+- Parameters- accelq url, userId, apiKey, tenant code, Job Id
+- Agent.properties file for you configured agent with
+
+### Steps to Integrate
+---
+
+**Step 1:** Copy your local `agent.properties` file from `` to root folder of your HyperExecute project.
+
+{/* **Step 2:** Download Accelq Node runner in root folder of your HyperExecute project and unzip the file.
+
+
+You can download the Node Runner from [here](https://accelq.s3.amazonaws.com/releases/plugins/6.0/accelq_ci_cd.tar.gz)
+ */}
+
+**Step 2:** Update your YAML file with your account credentials.
+
+**Step 3:** Execute HyperExcute job using the command:
+
+```
+./hyperexecute --config hyperdemo.yaml -u -k
+```
+
+## Additional Details
+### Where to Find the Parameters?
+
+#### AccelQ - URL, User-ID, API key, Tenant Code
+
+
+#### How to create a Job ID?
+
+**Step 1:** Create an LT profile with with the below configuration and save it
+
+
+**Step 2:** Create a [CI job](https://support.accelq.com/hc/en-us/articles/360016077871-How-do-I-create-a-job-that-I-can-invoke-from-CI-tool#:~:text=Step%201%3A%20On%20the%20ACCELQ,Click%20on%20%22Create%20Job%22) with the same profile and agent which has configured with it.
+
+
+
+**Step 3:** Copy the Job ID
+
+
+### Agent.properties file
+Agent.property file is a type of file that gets generated when you configures the agents from the Accelq to the .
+
+- You can configure your [ from Accelq Agent Dashboard](/support/docs/accelq-integration/#integrating-lambdatest-from-accelq-agent-dashboard)
+- You can also find the same at the location `(ACCELQAgent/AgentInstances//agent.properties)` in your local system.
+
+#### Sample File
+```bash
+# name of the agent, which will appear in your Run modal
+# must be a unique name across all projects in the tenant
+# only accepts alphabets, numeric and underscore (_)
+# Maximum length 32 characters.
+agent_name =
+
+# Port on which the Agent should run. Leave it blank to use an available port dynamically
+# agent_port=5000
+
+# ACCELQ server url along with port number (if applicable)
+accelq_server_url =
+
+# ACCELQ user id you use for login
+user_id =
+
+# API key (available in the profile menu under the auth properties once you login to ACCELQ)
+api_key =
+
+# Scope of the agent, which defines visibility (User, Project or Tenant)
+# "User" Agent is accessible only for the User starting this Agent
+# "Project" scope allows sharing the Agent for all Project users
+# "Tenant" scope allows all users on the Tenant to use this Agent
+agent_type = User
+
+# Project codes where this Agent should be visible, separated with a comma
+# Applicable only when scope of the Agent is set to "Project"
+# Project Code can be found in the profile menu under the auth properties once you login to ACCELQ
+# Example: project_code=proj1,proj2,proj3
+# project_code=
+
+# Web Provider Types - LOCALHOST, SAUCE_LABS, BROWSER_STACK, PERFECTO, LAMBDATEST, HEADSPIN, DIGITAL_AI
+# Refer to documentation for applicable properties for different providers
+web_provider_type = LAMBDATEST
+# web_provider_type=LOCALHOST
+web_provider_username =
+web_provider_password =
+# web_provider_cloud_name=
+# web_provider_security_token=
+# web_provider_serverUrl=
+# web_provider_hostname=
+# web_provider_port=
+# web_provider_data_center_endpoint=
+
+# Mobile Provider Types - LOCALHOST, SAUCE_LABS, BROWSER_STACK, PERFECTO, LAMBDATEST, HEADSPIN, DIGITAL_AI
+# Refer to documentation for applicable properties for different providers
+mobile_provider_type = LOCALHOST
+# mobile_provider_username=
+# mobile_provider_password=
+# mobile_provider_cloud_name=
+# mobile_provider_security_token=
+# mobile_provider_serverUrl=
+# mobile_provider_hostname=
+# mobile_provider_port=
+# mobile_provider_data_center_endpoint=
+
+# Browserstack Local Settings
+# auto_start_bs_local=true
+# browserstack_local_key=
+
+# Number of concurrent jobs to allow
+# Any invalid number will be considered as one concurrent job
+num_concurrent_jobs = 2
+
+# Number of parallel test cases to execute in a given job
+# Any invalid number will be considered as single thread
+num_parallel_tc_per_job = 4
+
+# Proxy settings for HTTP - uncomment following lines if applicable
+# http_proxy_host=
+# http_proxy_port=
+# http_proxy_user=
+# http_proxy_password=
+# http_proxy_nonproxyhosts=
+
+# Proxy settings for HTTPS - uncomment following lines if applicable
+# https_proxy_host=
+# https_proxy_port=
+# https_proxy_user=
+# https_proxy_password=
+# https_proxy_nonproxyhosts=
+
+# SSL Certificate Verification
+# ssl_cert_verification=true
+
+# Appuim URL
+appium_url = http://localhost:4723
+
+# TE Settings
+# te_start_server=false
+# te_server_port=9095
+
+# Indicates if the web driver should be auto-updated based on the browser version on the agent machine (local, server_side, off)
+# local : Fetch driver jars directly from the Agent host
+# server_side : Fetch driver jars from ACCELQ server connection
+# off : Do not auto-update the driver jars
+# web_driver_auto_update=local
+
+# Port numbers to use for virtualization servers
+# Leave this blank to use ports dynamically. If not, give the range with comma separation (e.g. 9000, 10000)
+# Number of available ports should be at least twice the number of concurrent threads running at any point
+# virtualization_ports_range=
+
+# Experimental Flags (Internal use only)
+agent_host = LT-MBP-194
+tenant_code = poc
+# work_root = file path of agent
+# Available Sharing Types: USER (0) or Shared (1)
+sharing_type = 0
+# cleanup_run_folders=true
+# virtualization_debug_log=true
+# run_re_trigger_timeout=30
+# tc_stmt_line_max_count=100000
+# sync_runtime=true
+# force_sync_runtime_at_startup=false
+# Available Image Qualities: high, medium or low
+# image_quality=high
+
+# Extra Flags
+provider_type = LAMBDATEST
+provider_password =
+provider_username =
+```
+
+### Sample YAML Files
+
+#### Single YAML File
+
+```bash
+version: 0.1
+user:
+key:
+globalTimeout: 150
+testSuiteTimeout: 150
+testSuiteStep: 150
+
+autosplit: true
+runson: win
+concurrency: 1
+
+pre:
+ - move agent.properties C:\Users\ltuser.ghtestVM\Downloads\acc_installer_win\ACCELQAgent\AgentInstances\agent\agent.properties #move your agent file to hyperex machines agent folder
+ - acc start # start accelq agent on hyperexecute machines
+
+testDiscovery:
+ type: raw
+ mode: dynamic
+ command: echo test
+
+testRunnerCommand: node $env:ACCELQ --url "https://poc.accelq.io" --userID "" --apiKey "" --tenantCode "poc" --jobID ""; C:\Users\ltuser.ghtestVM\Downloads\acc_installer_win\ACCELQAgent\Dashboard\AQAgentControllerShutdown.exe;
+```
+
+#### Parallel YAML File
+
+```bash
+version: 0.1
+globalTimeout: 150
+testSuiteTimeout: 150
+testSuiteStep: 150
+
+runson: win
+
+matrix:
+ jobID: ["",""]
+ agent: [hyper1\agent.properties,hyper2\agent.properties]
+
+exclusionMatrix:
+ - jobID: ['']
+ agent: [hyper2\agent.properties]
+ - jobID: ['']
+ agent: [hyper1\agent.properties]
+
+pre:
+ - move agent.properties C:\Users\ltuser.ghtestVM\Downloads\acc_installer_win\ACCELQAgent\AgentInstances\agent\agent.properties #move your agent file to hyperex machines agent folder
+ - acc start # start accelq agent on hyperexecute machines
+
+testSuites:
+ - node $env:ACCELQ --url "" --userID "" --apiKey "" --tenantCode "poc" --jobID $jobID;
+```
diff --git a/docs/hyperexecute-algoqa-integration.mdx b/docs/hyperexecute-algoqa-integration.mdx
new file mode 100644
index 000000000..7301ce377
--- /dev/null
+++ b/docs/hyperexecute-algoqa-integration.mdx
@@ -0,0 +1,169 @@
+---
+title: "Integrate algoQA with HyperExecute"
+sidebarTitle: "Run algoQA Tests"
+description: " Unleash the power of algoQA & TestMu AI HyperExecute! Streamline test management & experience fast execution."
+keywords: ['TestMu AI HyperExecute', 'TestMu AI HyperExecute help', 'TestMu AI HyperExecute documentation', 'algoQA', 'Integrations', 'Products', 'Test case management', 'Automated testing', 'Cloud-based testing']
+"og:description": " Unleash the power of algoQA & TestMu AI HyperExecute! Streamline test management & experience fast execution."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+algoQA is an AI Native software testing platform that automates end-to-end tests across web, mobile, desktop, and API applications. It generates optimal test cases, datasets, and executable scripts, reducing manual effort and improving test coverage.
+
+This document will guide you how to integrate your algoQA project with HyperExecute
+
+## Prerequisites
+
+To run the Tests on HyperExecute from your Local System, you are required:
+
+- Your [Username and Access key](/support/docs/hyperexecute-how-to-get-my-username-and-access-key/)
+- [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/) in order to initiate a test execution Job .
+- Setup the [Environment Variable](/support/docs/hyperexecute-environment-variable-setup/)
+- [HyperExecute YAML](/support/docs/hyperexecute-yaml-version0.2/) file which contains all the necessary instructions.
+
+## Step 1: Setup Your Test Suite
+
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample for the algoQA from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+## Step 2: Setup the CLI in your Test Suite
+
+After cloning / downloading the sample repo, you need to setup the CLI and the environment variables.
+
+### Download the HyperExecute CLI
+
+The CLI is used for triggering the tests on HyperExecute. It is recommend to download the CLI binary on the host system and keep it in the root directory of the suite to perform the tests on HyperExecute.
+
+You can download the CLI for your desired platform from the below mentioned links:
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| MacOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+### Setup Environment Variable
+
+Now, you need to export your environment variables *LT_USERNAME* and *LT_ACCESS_KEY* that are available in the [ Profile page](https://accounts.lambdatest.com/detail/profile).
+
+Run the below mentioned commands in your terminal to setup the CLI and the environment variables.
+
+
+
+
+
+ ```bash
+
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+ ```powershell
+
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+## Step 3: Configure YAML in your Test Suite
+
+```yaml
+---
+version: 0.1
+globalTimeout: 150
+testSuiteTimeout: 150
+testSuiteStep: 150
+
+runson: win
+
+autosplit: true
+
+retryOnFailure: true
+maxRetries: 1
+
+concurrency: 2
+
+cacheKey: '{{ checksum "pom.xml" }}'
+cacheDirectories:
+ - .m2
+
+pre:
+ - mvn -Dmaven.repo.local=./.m2 dependency:resolve
+
+report: true
+partialReports:
+ type: json
+ location: target/
+ frameworkName: extent-native
+
+uploadArtifacts:
+ - name: FinalReport
+ path:
+ - ExtentReports/**
+
+testDiscovery:
+ type: automatic
+ mode: static
+ args:
+ featureFilePaths: src/test/java/features/
+ frameWork: java
+
+testRunnerCommand: mvn test `-Dplatname=win `-Dmaven.repo.local=./.m2 `-Dcucumber.features="$test"
+
+jobLabel: ['HYP', 'algoQA']
+```
+
+## Step 4: Amend in your ApplicationSettings.xml file
+
+In your `ApplicationSettings.xml` file, update the following capabilities:
+
+- **BrowserType :** It should be Lambda.
+- **LambdaTestBuild :** Provide your build name.
+- **LambdaTestURL :** Provide your HUB URL. For e.g. `https://username:access-key@hub.lambdatest.com/wd/hub`
+
+## Step 5: Execute your Test Suite
+
+
+**NOTE :** In case of MacOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+Run the below command in your terminal at the root folder of the project:
+
+```bash
+./hyperexecute --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+```
+
+OR use this command if you have not exported your username and access key in the step 2.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+
+```
+
+## Step 6: Monitor the Test Execution
+
+Visit the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/hyperexecute) and check your Job status.
+
+
diff --git a/docs/hyperexecute-api-testing.mdx b/docs/hyperexecute-api-testing.mdx
new file mode 100644
index 000000000..00de20b9b
--- /dev/null
+++ b/docs/hyperexecute-api-testing.mdx
@@ -0,0 +1,164 @@
+---
+title: "Boost Your API Testing Efficiency with HyperExecute"
+sidebarTitle: "API Testing"
+description: "Master API Testing with HyperExecute! This technical doc explains API test automation using Hyperexecute. Learn how to ensure efficient API testing."
+keywords: ['hyperexecute api testing', 'api automation hyperexecute', 'run api tests hyperexecute', 'automate api testing with hyperexecute cloud platform', 'integrating hyperexecute with ci/cd for api testing', 'troubleshooting api tests in hyperexecute', 'api testing tools hyperexecute', 'api test scripts hyperexecute']
+"og:description": "Master API Testing with HyperExecute! This technical doc explains API test automation using Hyperexecute. Learn how to ensure efficient API testing."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+An API acts as a middleman between different software applications, allowing them to communicate and exchange data. Just like any other part of a software system, APIs need to be thoroughly tested to ensure they function as intended.
+
+## Why is API Testing Important?
+
+API testing is crucial for several reasons:
+
+- **Ensures application functionality:** It verifies that the API delivers the correct data and behaves as expected under various conditions.
+- **Catches bugs early:** By testing APIs early in the development process, you can identify and fix issues before they impact the overall application.
+- **Improves application reliability:** Robust API testing leads to a more stable and reliable application for end users.
+
+## How to Automate API Testing with Rest Assured?
+
+REST-Assured, a robust Java library, simplifies interacting with RESTful web services for testing purposes. It provides intuitive syntax for constructing requests and validating responses, streamlining API testing within Java environments.
+
+It is majorly used for:
+- Writing automated API tests
+- Validating REST API endpoints
+- Ensuring API reliability, performance, and security
+
+REST-Assured seamlessly integrates with popular testing frameworks like JUnit and TestNG, enabling organized and efficient test execution with its core capabilities:
+
+- Sending various HTTP requests (GET, POST, PUT, DELETE, etc.)
+- Parsing various response formats (JSON, XML, etc.)
+- Asserting response status codes and body content
+- Handling authentication mechanisms
+- Supporting data-driven testing with external data sources
+
+For e.g. REST-Assured provides function to write get method such as `given().when().get(url).then().log().all();` This will help you to call a get request to fetch all the data from the API. Once the Call is complete you can either verify using the response of that call or by checking the status of the request.
+
+```bash
+given().when().get(url).then().assertThat().statusCode(200);
+```
+
+- **Setting Base URI:** `RestAssured.baseURI` specifies the common part of API endpoints, avoiding repetition.
+
+- **Constructing Request:**
+ - **given()** initiates test case setup.
+ - **when()** sends the HTTP request (GET in this case).
+- **Capturing Response:**
+ - **then()** handles response handling and assertions.
+ - **log().all()** logs request and response details for debugging.
+ - **extract().response().asString()** extracts the response body as a string.
+
+## How to Test API on HyperExecute?
+
+### Step 1: Setup Your Test Suite
+
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample for the Maestro framework from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+
+### Step 2: Setup the CLI in your Test Suite
+
+After cloning / downloading the sample repo, you need to setup the CLI and the environment variables.
+
+#### Download the HyperExecute CLI
+
+The CLI is used for triggering the tests on HyperExecute. It is recommend to download the CLI binary on the host system and keep it in the root directory of the suite to perform the tests on HyperExecute.
+
+You can download the CLI for your desired platform from the below mentioned links:
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| MacOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+#### Setup Environment Variable
+
+Now, you need to export your environment variables *LT_USERNAME* and *LT_ACCESS_KEY* that are available in the [ Profile page](https://accounts.lambdatest.com/detail/profile).
+
+Run the below mentioned commands in your terminal to setup the CLI and the environment variables.
+
+
+
+
+
+ ```bash
+
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+ ```powershell
+
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+### Step 3: Configure YAML in your Test Suite
+
+```yaml reference title="hyperexecute.yaml"
+https://github.com/LambdaTest/hyp-api-testing/blob/master/hyperexecute.yaml
+```
+
+### Step 4: Execute your Test Suite
+
+
+**NOTE :** In case of MacOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+Run the below command in your terminal at the root folder of the project:
+
+```bash
+./hyperexecute --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+```
+
+OR use this command if you have not exported your username and access key in the step 2.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+
+```
+
+### Step 5: Monitor and Validate the Test Execution
+
+Visit the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/hyperexecute) and check your Job status.
+
+You can validate the tested API via the pre, post, and scenrios logs in the dashboard.
+
+#### pre
+
+
+
+#### scenario
+
+
+
+#### post
+
+
diff --git a/docs/hyperexecute-appium-testing.mdx b/docs/hyperexecute-appium-testing.mdx
new file mode 100644
index 000000000..d389740b6
--- /dev/null
+++ b/docs/hyperexecute-appium-testing.mdx
@@ -0,0 +1,288 @@
+---
+title: "Appium Testing - Real Device On HyperExecute"
+sidebarTitle: "Appium - Real Device"
+description: "Maximize Appium test execution with HyperExecute – Explore TestMu AI's support documentation for seamless automation testing."
+keywords: ['appium', 'java', 'testmu ai java', 'framework on testmu ai', 'testng', 'app testing', 'real devices']
+"og:description": "Maximize Appium test execution with HyperExecute – Explore TestMu AI's support documentation for seamless automation testing."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+This page outlines how to execute your Appium tests on HyperExecute using TestNG with YAML 0.2
+
+HyperExecute uses [YAML 0.2](/support/docs/hyperexecute-yaml-version0.2/) to perform the tests using Appium.
+
+
+## Prerequisites
+
+To run the Tests on HyperExecute from your Local System, you are required:
+
+- [HyperExecute YAML](/support/docs/hyperexecute-yaml-version0.2/) file which contains all the necessary instructions.
+- [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/) in order to initiate a test execution Job .
+- Your [Username and Access key](/support/docs/hyperexecute-how-to-get-my-username-and-access-key/)
+- Setup the Environmental Variable
+- Ensure you have Appium’s [Java client library](https://github.com/appium/java-client) installed.
+- Access to an **Android** app (.apk or .aab file) or an **iOS** app (.ipa file).
+
+
+**Sample repo**
+
+All the code samples in this documentation can be found on **'s Github Repository**. You can either download or clone the repository to quickly run your tests.
+
+
+If you do not have any **.apk** or **.ipa** file, you can run your sample tests on by using our sample 🔗 [Android app](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_android.apk) or sample 🔗 [iOS app](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_ios.ipa).
+
+
+
+### Download HyperExecute CLI
+
+The *HyperExecute CLI* is used for triggering tests on HyperExecute. It is recommend to download the HyperExecute CLI binary on the host system to perform the tests on HyperExecute. The CLI download site for various platforms is displayed below:
+
+| Platform | HyperExecute CLI download location |
+| ---------| --------------------------- |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+### Setup Environment Variable
+Export the environment variables *LT_USERNAME* and *LT_ACCESS_KEY* that are available in the [ Profile page](https://accounts.lambdatest.com/detail/profile).
+Run the below mentioned commands in the terminal to setup the CLI and the environment variables.
+
+
+
+
+
+ ```bash
+
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+ ```powershell
+
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+## Steps to Run Your Test
+
+### Step 1: Upload your Application
+Upload your _iOS_ application (.ipa file) or _android_ application (.apk file) to the servers using our REST API. You need to provide your Username and AccessKey in the format `Username:AccessKey` in the cURL command for authentication. Make sure to add the path of the appFile in the cURL request. Here is an example cURL request to upload your app using our REST API:
+
+
+
+
+
+
+
+```bash
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" --location --request POST 'https://manual-api.lambdatest.com/app/upload/realDevice' --form 'name="Android_App"' --form 'appFile=@""'
+
+
+```
+
+
+
+
+```powershell
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" -X POST "https://manual-api.lambdatest.com/app/upload/realDevice" -F "appFile=@"""
+
+
+```
+
+
+
+
+
+
+
+
+
+```bash
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" \\
+--location --request POST 'https://manual-api.lambdatest.com/app/upload/realDevice' \\
+--form 'name="Android_App"' \\
+--form 'url="https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_android.apk"'
+
+```
+
+
+
+
+```powershell
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" --location --request POST "https://manual-api.lambdatest.com/app/upload/realDevice" --header "Content-Type: application/x-www-form-urlencoded" --data-urlencode "url=:https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_android.apk" --data-urlencode "name=Proverbial_App"
+
+```
+
+
+
+
+
+
+
+Response of above cURL will be a **JSON** object containing the `App URL` of the format - ``lt://APP123456789123456789`` and will be used in the next step.
+
+
+### Step 2: Configure your Test Script
+Write Your Automation Script in the client language of your choice from the ones supported by Appium. An automation script for the sample applications have been provided below.
+
+Here is a sample automation script in Java for the sample app downloaded above. Ensure to update the `app_url`, `username` and `accesskey` in the below code.
+
+
+
+
+```java reference title="AndroidApp.java"
+https://github.com/LambdaTest/hyperexecute-real-device-appium-testng/blob/main/src/main/java/AndroidApp.java
+```
+
+
+
+
+```java reference title="iOSApp.java"
+https://github.com/LambdaTest/hyperexecute-real-device-appium-testng/blob/main/src/main/java/iOSApp.java
+```
+
+
+
+
+### Step 3: Update your XML file
+Create `.XML` file in order to run your test and define device capabilities. Please find sample code below for the same.
+
+
+
+```xml reference title="android-parallel.xml"
+https://github.com/LambdaTest/hyperexecute-real-device-appium-testng/blob/main/src/test/java/android-parallel.xml
+```
+
+
+
+```xml reference title="ios-parallel.xml"
+https://github.com/LambdaTest/hyperexecute-real-device-appium-testng/blob/main/src/test/java/ios-parallel.xml
+```
+
+
+
+### Step 4: Configure YAML and Execute your Script
+
+
+```yaml reference title="android-parallel.yaml"
+https://github.com/LambdaTest/hyperexecute-real-device-appium-testng/blob/main/yaml/android/hyp-rd-android-multiple.yaml
+```
+
+
+
+```yaml reference title="ios-parallel.yaml"
+https://github.com/LambdaTest/hyperexecute-real-device-appium-testng/blob/main/yaml/ios/hyp-rd-ios-multiple.yaml
+```
+
+
+
+
+The ```region``` parameter specifies the region or location where the Appium tests will be executed. Our platform supports the following three regions:
+
+- ap (Asia-Pacific)
+- us (United States)
+- eu (European Union)
+
+### Step 5: Execute your Test Suite
+
+**NOTE :** In case of MacOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+Run the below command in your terminal at the root folder of the project:
+
+```bash
+./hyperexecute --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+```
+
+OR use this command if you have not exported your username and access key in the step 2.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+
+```
+
+## Configure Smart UI
+
+To configure SmartUI with HyperExecute, you need to simply add a capability in your test file:
+
+```bash java
+"smartUI.project": ""
+```
+
+
+Refer to the [Automation Capabilities Generator](https://www.testmuai.com/capabilities-generator/) to understand how to write the capability in different languages.
+
+
+
+
+## More About Desired Capabilities
+Sample Capabilities for both android and iOS are mentioned below -
+
+
+
+```java
+{
+ "deviceName": "Galaxy Tab S4",
+ "platformName": "android",
+ "platformVersion": "10",
+ "app": "App_url",
+ "visual": True,
+ "console": True,
+ "deviceOrientation": "PORTRAIT",
+ "build": "new-12",
+ "isRealMobile": True,
+}
+```
+
+
+
+
+```java
+{
+ "deviceName": "iPhone 12 Mini",
+ "platformName": "ios",
+ "platformVersion": "14",
+ "app": "App_url",
+ "isRealMobile": True,
+ "visual": True,
+ "console": True,
+ "build": "lt-web-4",
+ "network": True,
+}
+```
+
+
+
+
+
+For more details, please refer to our guide on [Desired Capabilities in Appium](/support/docs/desired-capabilities-in-appium/).
+
+
+## Navigation in Automation Dashboard
+
+Every test run on the HyperExecute has a unique *jobId* associated with it. Each *jobId* can in turn constitute single (or multiple) *groupId*(s). You can visit [HyperExecute automation dashboard](https://automation.lambdatest.com/hyperexecute/) for checking the status of the test execution.
+
+The snapshot below shows how to navigate to the respective *testID* for viewing the Selenium logs:
+
+
diff --git a/docs/hyperexecute-appium-virtual-device.mdx b/docs/hyperexecute-appium-virtual-device.mdx
new file mode 100644
index 000000000..9c60ef3de
--- /dev/null
+++ b/docs/hyperexecute-appium-virtual-device.mdx
@@ -0,0 +1,190 @@
+---
+title: "Appium Testing - Virtual Device On HyperExecute"
+sidebarTitle: "Appium - Virtual Device"
+description: "Execute Appium tests on virtual devices using HyperExecute with TestNG and YAML 0.2. Learn setup, configuration, and seamless test execution steps."
+keywords: ['appium', 'java', 'testmu ai java', 'framework on testmu ai', 'testng', 'app testing', 'virtual devices']
+"og:description": "Execute Appium tests on virtual devices using HyperExecute with TestNG and YAML 0.2. Learn setup, configuration, and seamless test execution steps."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+This page outlines how to execute your Appium tests on HyperExecute using TestNG with YAML 0.2
+
+HyperExecute uses [YAML 0.2](/support/docs/hyperexecute-yaml-version0.2/) to perform the tests using Appium.
+
+
+## Prerequisites
+
+To run the Tests on HyperExecute from your Local System, you are required:
+
+- [HyperExecute YAML](/support/docs/hyperexecute-yaml-version0.2/) file which contains all the necessary instructions.
+- [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/) in order to initiate a test execution Job .
+- Your testmu ai [Username and Access key](/support/docs/hyperexecute-how-to-get-my-username-and-access-key/)
+- Setup the Environmental Variable
+- Ensure you have Appium’s [Java client library](https://github.com/appium/java-client) installed.
+- Access to an **Android** app (.apk or .aab file)
+
+
+**Sample repo**
+
+All the code samples in this documentation can be found on **'s Github Repository**. You can either download or clone the repository to quickly run your tests.
+
+
+
+
+If you do not have any **.apk** file, you can run your sample tests on by using our sample 🔗 [Android app](https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_android.apk)
+
+
+
+### Download HyperExecute CLI
+
+The *HyperExecute CLI* is used for triggering tests on HyperExecute. It is recommend to download the HyperExecute CLI binary on the host system to perform the tests on HyperExecute. The CLI download site for various platforms is displayed below:
+
+| Platform | HyperExecute CLI download location |
+| ---------| --------------------------- |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+### Setup Environment Variable
+Export the environment variables *LT_USERNAME* and *LT_ACCESS_KEY* that are available in the [ Profile page](https://accounts.lambdatest.com/detail/profile).
+Run the below mentioned commands in the terminal to setup the CLI and the environment variables.
+
+
+
+
+
+ ```bash
+
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+ ```powershell
+
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+## Steps to Run Your Test
+
+### Step 1: Upload your Application
+Upload your _android_ application (.apk file) to the servers using our REST API. You need to provide your Username and AccessKey in the format `Username:AccessKey` in the cURL command for authentication. Make sure to add the path of the appFile in the cURL request. Here is an example cURL request to upload your app using our REST API:
+
+
+
+
+
+
+
+```bash
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" --location --request POST 'https://manual-api.lambdatest.com/app/upload/virtualDevice' --form 'name="Android_App"' --form 'appFile=@""'
+
+
+```
+
+
+
+
+```powershell
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" -X POST "https://manual-api.lambdatest.com/app/upload/virtualDevice" -F "appFile=@"""
+
+
+```
+
+
+
+
+
+
+
+
+
+```bash
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" \\
+--location --request POST 'https://manual-api.lambdatest.com/app/upload/virtualDevice' \\
+--form 'name="Android_App"' \\
+--form 'url="https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_android.apk"'
+
+```
+
+
+
+
+```powershell
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" --location --request POST "https://manual-api.lambdatest.com/app/upload/virtualDevice" --header "Content-Type: application/x-www-form-urlencoded" --data-urlencode "url=:https://prod-mobile-artefacts.lambdatest.com/assets/docs/proverbial_android.apk" --data-urlencode "name=Proverbial_App"
+
+```
+
+
+
+
+
+
+
+Response of above cURL will be a **JSON** object containing the `App URL` of the format - ``lt://APP123456789123456789`` and will be used in the next step.
+
+
+### Step 2: Configure your Test Script
+Write Your Automation Script in the client language of your choice from the ones supported by Appium. An automation script for the sample applications have been provided below.
+
+Here is a sample automation script in Java for the sample app downloaded above. Ensure to update the `app_url`, `username` and `accesskey` in the below code.
+
+```java reference title="AndroidEmulator.java"
+https://github.com/LambdaTest/hyperexecute-appium-testng/blob/android-emulator/src/main/java/AndroidEmulator.java
+```
+
+### Step 3: Update your XML file
+Create `.XML` file in order to run your test and define device capabilities. Please find sample code below for the same.
+
+```xml reference title="android-emulator.xml"
+https://github.com/LambdaTest/hyperexecute-appium-testng/blob/android-emulator/src/test/java/android-emulator.xml
+```
+
+### Step 4: Configure YAML and Execute your Script
+```yaml reference title="android-emulator.yaml"
+https://github.com/LambdaTest/hyperexecute-appium-testng/blob/android-emulator/yaml/hyp-android-emulator.yaml
+```
+
+{/* > The ```region``` parameter specifies the region or location where the Appium tests will be executed. Our platform supports the following three regions:
+- ap (Asia-Pacific)
+- us (United States)
+- eu (European Union) */}
+
+### Step 5: Execute your Test Suite
+
+**NOTE :** In case of MacOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+Run the below command in your terminal at the root folder of the project:
+
+```bash
+./hyperexecute --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+```
+
+OR use this command if you have not exported your username and access key in the step 2.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+
+```
diff --git a/docs/hyperexecute-artifacts.mdx b/docs/hyperexecute-artifacts.mdx
new file mode 100644
index 000000000..f0ad518c7
--- /dev/null
+++ b/docs/hyperexecute-artifacts.mdx
@@ -0,0 +1,143 @@
+---
+title: "Job Artifacts"
+sidebarTitle: "Upload & Download Artifacts"
+description: "Learn how to generate the Artifacts for your desired framework and seamlessly interact with artifacts through the HyperExecute UI."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation']
+"og:description": "Learn how to generate the Artifacts for your desired framework and seamlessly interact with artifacts through the HyperExecute UI."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Artifacts are files generated during test execution, including reports and logs. You can refer to these files for obtaining consolidated information about the executed test cases, and can seamlessly interact with artifacts through the HyperExecute UI.
+
+Following the completion of a Job, these artifacts are automatically stored in the **artifacts folder**, distinguishing previous files into **old-artifacts** on subsequent runs while retaining the recent files in artifacts.
+
+## Steps to Generate and Download Artifacts
+Follow the below mentioned steps to generate the Artifacts for your desired framework:
+
+**Step 1:** Go to the HyperExecute YAML file
+
+**Step 2:** Add the below mentioned parameters in the YAML file to generate the Artifacts
+
+```yaml
+uploadArtifacts:
+ - name: Executed-Job-Artifacts #user defined name of the artifact
+ path:
+ - src/test/index.html #path of the generated artifact
+ - name: My-Job-Artifacts
+ path:
+ - src/collect/info.html
+```
+
+- If you are generating multiple artifacts, then it is recommended to use this parameter, [`mergeArtifacts`](/support/docs/deep-dive-into-hyperexecute-yaml/#mergeartifacts) in your YAML, as it will zip all your Artifacts files while downloading from the dashboard.**
+
+- You can replace the Artifacts folder name value with any of the Matrix parameters value.
+
+```yaml
+matrix:
+ os: [win]
+ browser: ["chrome-latest-1", "firefox-latest-2"]
+
+mergeArtifacts: true
+uploadArtefacts:
+ - name: $browser
+ path:
+ - allure-results/
+```
+
+As shown in the above code, the artifacts folder generated will be named **chrome-latest-1** and **firefox-latest-2**
+
+
+**Step 3:** Now trigger your job and go to the [HyperExecute](https://hyperexecute.lambdatest.com/hyperexecute/jobs) dashboard.
+
+**Step 4:** Click on any of the artifacts generated. You can also download the artifacts from the dashboard
+
+
+
+Here is the sample artifact generated.
+
+
+
+## Construct artifact URLs
+
+HyperExecute also allows you to access your _Artifacts_ directly from the HyperExecute UI and create shareable URLs for them.
+
+### Navigating Artifacts
+
+To view or download your Artifacts, click the **Artifacts** button.
+
+
+
+#### For a Single file
+
+If you only have one file as an _Artifact_, then a preview of the file will be opened on your browser.
+
+
+
+#### For Multiple files
+
+If you have multiple files as an _Artifact_, then you will get an option to download all the files directly.
+
+
+
+### Managing Test Artifacts URL
+
+To make the most of this feature, follow the steps below.
+
+
+**Prioritize**: To access your _Artiacts_ for a particular _Job ID_, they must have a name.
+
+
+#### 1. Constructing the URL
+
+The URL to view an _Artifact_ in a standard job is:
+
+`https://hyperexecute.lambdatest.com/artifact/view/?artifactName=`
+
+- Insert the **_Job ID_** of your test and the name of your _Artifact_ in place of the `` and `` placeholder values.
+
+- This URL will take you to a page where you can access the _Artifact_ and its contents.
+
+For example, if you want to access the _Artifacts_ for a job with _Job ID_: `2d835a95-e7ea-4ea7-83e8-608c2f71d95c`, and the name of your _Artifact_ is `ExecutionSnapshots`, then your URL should be:
+
+`https://hyperexecute.lambdatest.com/artifact/view/`**2d835a95-e7ea-4ea7-83e8-608c2f71d95c**`?artifactName=`**ExecutionSnapshots**
+
+
+
+***
+
+#### 2. Additional Filters
+
+You can also use this feature to cycle through the files in your _Artifacts_.
+
+**1. `filter=*.log`:** You can filter through all of your files by adding this at the end of your URL. However, you will have to insert the entire path of your _Artifacts_ folder or the names of the folder you want to use the filter in.
+
+- For example, if you want to filter through the `.html` files of a folder called `site` with the path `/target/site/`, for the same job that was used above, then your URL will be:
+
+`https://hyperexecute.lambdatest.com/artifact/view/2d835a95-e7ea-4ea7-83e8-608c2f71d95c?artifactName=ExecutionSnapshots&`**filter=target/site/*.html**
+
+
+
+***
+
+**2. `view=flat`:** If you add this at the end of the Artifact URL, then you will be able to view your artifacts in a list instead of a tree structure.
+
+- For example, if you want to view the results of the filter used above in a flat manner, then your URL will be:
+
+`https://hyperexecute.lambdatest.com/artifact/view/2d835a95-e7ea-4ea7-83e8-608c2f71d95c?artifactName=ExecutionSnapshots&filter=target/site/*.html&`**view=flat**
+
+
+
+***
+
+**3. `&taskId=`:** If you want to access the Artifacts for a particular task, then add this in your URL.
+
+- For example, if you want to view the _Artifacts_ for a task with _Task ID_ `df8604cf-7af2-48b6-903d-786028078640` for the same job that was used above, then your URL will be:
+
+`https://hyperexecute.lambdatest.com/artifact/view/2d835a95-e7ea-4ea7-83e8-608c2f71d95c?artifactName=ExecutionSnapshots&`**taskId=2731df9f-bc9f-4fbc-85c4-fe675aeffeb7**
+
+
+
+***
diff --git a/docs/hyperexecute-auto-healing.mdx b/docs/hyperexecute-auto-healing.mdx
new file mode 100644
index 000000000..78d4e294d
--- /dev/null
+++ b/docs/hyperexecute-auto-healing.mdx
@@ -0,0 +1,89 @@
+---
+title: "Auto Healing in HyperExecute"
+sidebarTitle: "Auto-Heal Broken Locators"
+description: "This documentation will help you to understand the concept of auto healing in hyperexecute"
+keywords: ['hyperexecute auto healing', 'auto healing', 'recover flaky tests']
+"og:description": "This documentation will help you to understand the concept of auto healing in hyperexecute"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+This is currently in the **Beta** version.
+
+
+HyperExecute's Auto Healing feature helps you enhance the robustness of the test suites by automatically overcoming certain types of unexpected failures during the execution of your test scripts.
+
+## Enable Auto Healing
+
+**Step 1:** To еnablе thе Auto Hеaling fеaturе, you nееd to pass thе **`autoHеal: truе`** as a capability in your WеbDrivеr configuration.
+
+```yaml
+const capability = {
+ "browserName": "Chrome",
+ "LT:Options": {
+ "platformName": "Windows 10",
+ # highlight-next-line
+ "autoHeal": true
+ }
+}
+```
+**Step 2:** Now, trigger your test on HyperExecute using the mentioned command. Please replace the placeholder values with your details.
+
+ ```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+
+```
+
+**Step 3:** Now visit the HyperExecute Dashboard to check your triggered test. Click on the **View Test Detail** button.
+
+**Step 4:** Click on the **band-aid** icon as shown below to check what part of your test case is healed.
+
+
+
+## How Auto Healing Works
+
+Auto Healing employs a dynamic locator strategy that adapts to DOM (Document Object Model) changes in real-time. When an element is initially located, the system records its DOM path and associated attributes. If subsequent attempts to find the element fail due to application updates, the Auto Healing mechanism activates. It analyzes the current DOM structure, comparing it against the previously recorded state, and generates new, contextually relevant locators by intelligently combining element attributes and hierarchical information. This process occurs seamlessly during test runtime, allowing scripts to continue execution despite locator changes. The system continuously monitors the web page for DOM modifications, ensuring sustained test reliability even in the face of frequent application updates.
+
+## Using AutoHeal with Hooks
+
+In addition to enabling AutoHeal globally through capabilities, HyperExecute also supports **AutoHeal Hooks** for fine-grained control during test execution.
+
+These hooks allow you to **start or stop the AutoHeal mechanism dynamically** at any point within your Selenium test scripts. This is especially useful when only certain test steps involve dynamic elements or frequently changing locators.
+
+By using these hooks, you can:
+- Start AutoHeal before performing actions on elements likely to change.
+- Stop AutoHeal immediately after those interactions are completed.
+- Ensure the rest of your test executes with standard Selenium behavior.
+
+This provides precise control over when element healing should be applied, improving reliability and reducing flakiness without impacting unrelated steps.
+
+
+To learn how to use AutoHeal hooks in your Selenium scripts, refer to the detailed guide: [How to Use AutoHeal using Hooks](/support/docs/autoheal-with-hooks/)
+
+
+## Benefits of Auto Healing
+Here are some of the benefits of using HyperExecute's Auto Healing feature:
+
+- **Reduces the number of Flaky Tests:** Flaky tests are tests that fail intermittently, even though the underlying code has not changed. This can be caused by a variety of factors, such as unstable test environments, network latency, or changes in the browser's rendering engine. Auto Healing can help reduce the number of flaky tests by automatically retrying failed tests a certain number of times.
+- **Improves Test Reliability:** By automatically recovering from failures, Auto Healing can help improve the reliability of your test suite. This means that you can be more confident that your tests will always pass, even if there are temporary disruptions to the test environment.
+- **Saves Time and Effort:** Auto Healing can help save you time and effort by automating the process of recovering from failures. This means that you can focus on other tasks, such as developing new tests or fixing bugs.
+
+## Limitations
+While the Auto Healing feature is designed to handle a wide range of issues, there are certain limitations to be aware of:
+
+- **Non-recoverable Errors:** Auto Healing cannot recover from certain types of errors, such as WebDriver initialization errors or system-level failures.
+- **Test Accuracy:** While Auto Healing can reduce test flakiness, it may also mask real issues in your application or test scripts. It's important to review the logs and understand why a test needed healing.
+- **Performance Impact:** While typically minimal, enabling Auto Healing can have a slight impact on test execution time due to the additional checks and recovery mechanisms.
+
+## Best Practices
+By following these best practices, you can use auto healing to improve the reliability and efficiency of your test suite without introducing new risks.
+
+- Use a test automation framework that supports Auto Healing. This will make it easier to implement and manage Auto Healing in your test suite.
+- Identify the types of errors that you want to recover from. Not all errors can be recovered automatically. Focus on recovering from the most common and impactful errors.
+- Configure auto healing to retry tests a limited number of times. This will help to prevent infinite loops and resource exhaustion.
+- Log all Auto Healing activity. This will help you understand why tests are failing and to troubleshoot any problems that occur.
+- Monitor the effectiveness of Auto Healing. Track the number of tests that are healed and the number of false positives. This will help you to determine whether or not auto healing is providing a net benefit.
diff --git a/docs/hyperexecute-auto-split-strategy.mdx b/docs/hyperexecute-auto-split-strategy.mdx
new file mode 100644
index 000000000..ee852f8f4
--- /dev/null
+++ b/docs/hyperexecute-auto-split-strategy.mdx
@@ -0,0 +1,95 @@
+---
+title: "AutoSplit Strategy"
+sidebarTitle: "Split Tests Automatically (AutoSplit)"
+description: "Explore HyperExecute Auto Split Strategy | Optimize Testing Efficiency - Discover how HyperExecute revolutionizes testing with auto split strategy for enhanced efficiency."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation']
+"og:description": "Explore HyperExecute Auto Split Strategy | Optimize Testing Efficiency - Discover how HyperExecute revolutionizes testing with auto split strategy for enhanced efficiency."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+The Smart **Auto Split Strategy** enables you to distribute tests across multiple virtual machines efficiently. This strategy ensures optimal utilization of concurrency by allowing you to split tests based on various levels, such as files, modules, and scenarios.
+
+## Key Benefits of Auto Split Strategy
+- Efficient distribution of tests across nodes.
+- Fine-grained control over test distribution.
+- Maximization of concurrency for faster results.
+- [Automatic reordering of test cases](/support/docs/hyperexecute-auto-split-strategy/#automatic-reordering-of-test-cases), prioritizing failed ones for faster feedback in subsequent executions.
+
+
+
+
+HyperExecute provides flexibility to distribute tests at file level, scenario level, module level, and practically anything, provided you have a way to list down all the possible values of the entity that has to be distributed.
+
+
+## Enabling Auto-Test Splitting
+
+For enabling auto-test splitting, set the `autosplit` key to *true* in the HyperExecute YAML file.
+
+``` yaml
+autosplit: true
+```
+
+Along with that, you need to provide [`testDiscovery`](/support/docs/deep-dive-into-hyperexecute-yaml/#testdiscovery) and [`testRunnerCommand`](/support/docs/deep-dive-into-hyperexecute-yaml/#testrunnercommand) flags in your YAML file as well.
+
+### Configuration Parameters
+
+#### 1. `concurrency`
+The `concurrency` key indicates the total number of concurrent sessions that can run in parallel. With both of these commands (`testDiscovery` and `testRunnerCommand`), HyperExecute intelligently distributes tests over multiple virtual machines as specified by the `concurrency` directive in the YAML file.
+
+For example, assume that the total number of test scenarios [discovered via `testDiscovery`] are 27 and `concurrency` is set to 7. In this case, HyperExecute would allocate 7 nodes for running the 27 tests in parallel.
+
+``` yaml
+concurrency: 7
+```
+
+#### 2. `testDiscovery`
+- It is used to list down all the values to be distributed. HyperExecute will execute the **`testDiscovery`** command verbatim and expects distinct values to be on separate lines. It can be as simple as a list of files on different lines.
+- This can be used later to split tests over files, modules, or any level supported by your [language and framework](/support/docs/hyperexecute-supported-languages-and-frameworks/).
+- It is used for locating/discovering the tests that are a part of the project. You can use the combination of *grep*, **`awk`**, **`sed`**, or any valid command to locate the tests that you intend to run. For NodeJS, usually at file level, for Python at class level, in Java at class and module level. For Cucumber based frameworks at scenario level or feature level or at tag level.
+
+A few samples are given below:
+
+```yaml
+# The following command (or value) when assigned to testDiscoverer key searches for the scenarios by matching the string Scenario [or Scenario Outline] in the .feature files located in the *src* directory of the project.
+testDiscovery:
+ type: raw
+ mode: dynamic
+ command: grep -nri 'Scenario:\^|Scenario Outline:' src -ir --include=\*.feature | awk '{print $1}' | sed 's/\.\///g' | sed 's/\(.*\):/\1 /'
+```
+
+```yaml
+testDiscovery:
+ type: raw
+ mode: dynamic
+ command: grep 'class name' testng.xml | awk '{print$2}' | sed 's/name=//g' | sed 's/\x3e//g'
+```
+
+#### 3. `testRunnerCommand`
+- It is used to run a single item from the **`testDiscovery`**. You need to add **`$test`** in the `testRunnerCommand` for interpolating one of the values from the `testDiscovery`.
+- It tells the system how to run a single test entity in isolation. This entity could be a file, module, feature or scenario. Test runner command will run over each of the values extracted from the `testDiscovery` command.
+
+## Advanced Concepts
+
+### Automatic Reordering of Test Cases
+
+Suppose you are performing regression testing in your large test suite project via github actions, but some test cases are failing unexpectedly for no reason. These flaky tests have become a time-consuming nightmare for QA and developers. After fixing the issues, you trigger the testing pipeline again, but you have to wait to check the status of that particular test.
+
+It would be much better if those flaky tests ran first in the sequence, so you don't have to wait longer to see the status of your previously failed tests.
+
+That's exactly the problem HyperExecute's autosplit with automatic re-ordering aims to solve! It's like having a testing assistant who remembers which tests were tricky last time.
+
+#### How does it work?
+When you run tests with HyperExecute's autosplit feature, your tests are divided up and run simultaneously on multiple machines, executing them in parallel. This is great for speeding things up, but during this run, HyperExecute keeps track of which tests fail.
+
+After the initial run is complete, HyperExecute takes note of the failing tests. It may use this information to automatically reorder your tests for the next time you run them.
+
+On subsequent runs, HyperExecute might prioritize the failing tests from the previous run for faster feedback.
+
+
+
+
+Automatic reordering is a behind-the-scenes feature that optimizes test execution. You don't need to specifically configure it; it might happen automatically as part of the autosplit process. It's like a hidden perk that can significantly improve your testing experience.
+
diff --git a/docs/hyperexecute-azure-test-plan.mdx b/docs/hyperexecute-azure-test-plan.mdx
new file mode 100644
index 000000000..049596b09
--- /dev/null
+++ b/docs/hyperexecute-azure-test-plan.mdx
@@ -0,0 +1,220 @@
+---
+title: "Azure Test Plan Integration with HyperExecute"
+sidebarTitle: "Integrate Azure Test Plans"
+description: "Seamless Azure Test Plan integration with HyperExecute. Set up your Test Plan, associate automation test cases, and run the plan on HyperExecute in three steps."
+keywords: ['hyperexecute integrations', 'hyperexecute integrations with products', 'products', 'azure test plan', 'azure integration']
+"og:description": "Seamless Azure Test Plan integration with HyperExecute for efficient test management and execution. Boost software quality effortlessly."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+It is a **Premium** feature of Azure. You will have to buy access to [Azure Test Plans](https://learn.microsoft.com/en-us/azure/devops/organizations/billing/buy-access-tfs-test-hub?view=azure-devops-2022#buy-monthly-access-to-azure-test-plans)
+
+
+In this fast-paced world of software development, ensuring fast and quality testing cycle in not an option anymore, but a necessity. Imagine a scenario where your team is diligently working on a project, but managing test plans, suites, spreadsheets, and cases becomes a maze of complexity. This is where Azure Test Plan comes in as your bestfriend.
+
+Azure Test Plan is a Microsoft Azure cloud-based testing service that allows you to manage test plans, test suites, and test cases for your web and desktop applications. Using test plans, you can Azure Test Plans also provides a browser extension for exploratory testing and gathering feedback from stakeholders.
+
+It includes other features as well to assist you in improving the quality of your software, including:
+
+- **Test Case Management:** You can create, edit, and organize your test cases in a central location.
+- **Test Execution:** Run your test cases manually or using automated tools.
+- **Defect Tracking:** You can track and manage bugs and other issues found during testing.
+- **Reporting:** Generate reports to track your testing progress and identify areas for improvement.
+
+## Steps to Integrate Test Plan with HyperExecute
+
+Integrate the Azure Test Plan with HyperExecute in just 3 simple steps 🚀
+
+1. **Step 1: Setup the Azure Test Plan** — Create your Test Plan, suite, and test case in the Azure Test Plan Dashboard.
+2. **Step 2: Associate the Test Cases** — Associate your automation tests with the Azure Test Case IDs.
+3. **Step 3: Integrate the Test Plan with HyperExecute** — Run the associated Test Plan on HyperExecute.
+
+Complete the steps below in order — a reader does Step 1, then Step 2, then Step 3.
+
+## Step 1: Setup the Azure Test Plan
+
+
+You need to first [**setup the Azure Test Plan**](https://learn.microsoft.com/en-us/azure/devops/test/create-a-test-plan?view=azure-devops#prerequisites) Project before integrating HyperExecute with it.
+
+
+**Step 1:** Login to your [Azure DevOps](https://dev.azure.com/) account.
+
+**Step 2:** Click on the New Project button. Enter the basic details like **Project Name**, **Visibility**. Click on **Create Project** button.
+
+
+
+**Step 3:** Click on Test Plans option in the left pane. Then, click on New Test Plan to start creating new Test Plan.
+
+
+
+**Step 4:** Enter the **Name** of the Test Plan, choose the **Area Path**, and select the **iteration**. Click on Create button.
+
+
+
+{/*
*/}
+
+**Step 5:** Now, hover over the test plan name and click on the three-dots. Click on **New Suite** >> **Static Suite**. Set a name for the Suite.
+
+
+
+**Step 6:** Your test suite is now created. Click on **New Test Case** button and create a new test case. Once created, click on **Save and Close**.
+
+
+
+
+
+Once created, you will see a screen something similar to below
+
+
+
+## Step 2: Associate the Test Cases with Azure Test Plan
+
+
+Test Plan works in Association with specific [**Visual Studio subscriptions**](https://learn.microsoft.com/en-us/azure/devops/test/create-a-test-plan?view=azure-devops#:~:text=Basic%20%2B%20Test%20Plans%20access%20level%20to%20add%20test%20plans%20and%20test%20suites%2C%20delete%20test%20artifacts%2C%20and%20define%20test%20configurations.%20Or%2C%20have%20one%20of%20the%20following%20Visual%20Studio%20subscriptions).
+
+
+After setting up a Test Plan, now you need to associate your test cases as well with the Test Plan. To perform the same, we must have a Visual Studio IDE installed in our local machine. Login with same credentials for Visual Studio as in Test Plan.
+
+Follow the steps below to compelete the test case association:
+
+**Step 1:** In your Visual Studio Code IDE, click on a **sln** file in a **C# project**.
+
+
+**NOTE :** Login with the same credentials for Visual Studio as in the Test Plan.
+
+
+
+
+**Step 2:** Navigate to the Team Explorer view.
+
+
+
+**Step 3:** Click the **Home** icon and pull down the list to the right of Home icon.
+
+- Select the **Projects and My Teams** >> **Manage Connections**.
+
+- Click on **Manage Connections** >> **Connect to a Project**.
+
+
+
+**Step 4:** Select your repository, click the right button of your mouse, and then click the **Connect** button.
+
+
+**NOTE :** The connection might ask you to connect with GitHub; please provide access to GitHub as well.
+
+
+
+
+**Step 5:** Once connected, click on the **Test** menu, then **Test Explorer**.
+
+
+
+**Step 6:** Inside the Test Explorer, select any test, right click and select **Associate to Test Case**.
+
+
+
+**Step 7:** Enter the **Test Case ID**, click on **Add Association**, and then click the **Save** button. This will associate the test with the Test Case ID in the Test Plan.
+
+
+
+**Step 8:** You can check the associated test in test plan by hovering on three dots beside test case name and click on Open Test Case.
+
+
+
+Associated test cases will look like this:
+
+
+
+## Step 3: Integrate the Test Plan with HyperExecute
+
+
+Test Distribution of the suite is recommended to be at **test level** such that each HyperExecute stage has one test.
+
+
+To execute the Test Plan with HyperExecute, you will have to follow the below mentioned steps:
+
+**Step 1:** Download these exeutable files and place it in the root directory of your test suite.
+
+| Binary | Download Link |
+|--------|---------------|
+| Testplan Discovery | https://downloads.lambdatest.com/hyperexecute/testplan-discovery-win.exe |
+| Testplan Status | https://downloads.lambdatest.com/hyperexecute/testplan-status-update-win.exe |
+| Test Link Attachment | https://downloads.lambdatest.com/hyperexecute/test-link-attach-win.exe |
+
+**Step 2:** Add the following command in your YAML file
+
+```yaml
+testDiscovery:
+ command: testplan-discovery-win.exe
+ mode: static
+ type: raw
+```
+
+**Step 3:** To keep the test case distribution perfectly, make sure you pass the `dynamicAllocation` flag as `true`.
+
+```yaml
+dynamicAllocation: true
+```
+
+**Step 4:** Now, you need to pass the following command in your YAML file.
+
+```yaml
+testRunnerCommand: dotnet test path\of\dll --settings path\of\runsettings --filter '"Name=$test"' ; ./testplan-status-update-win.exe ; ./test-link-attach-win.exe
+```
+
+**Step 5:** Trigger your test plan on HyperExecute.
+
+- Download the Hyperexecute CLI Binary based on the OS you use.
+
+| Platform | Download Link |
+|-----------|--------------|
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+- Run the below mentioned commands in your terminal to setup the CLI and the environment variables.
+
+
+
+
+
+ ```bash
+
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+ ```powershell
+
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+In case of MAC, if you get a permission denied warning while executing CLI, simply run `chmod u+x ./hyperexecute` to allow permission. In case you get a security popup, allow it from your **System Preferences → Security & Privacy → General tab**.
+
+
+- Run the below command in your terminal at the root folder of the project
+
+```bash
+./hyperexecute --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+```
+
+OR use this command if you have not exported your username and access key.
+
+```bash
+./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+```
diff --git a/docs/hyperexecute-background-services.mdx b/docs/hyperexecute-background-services.mdx
new file mode 100644
index 000000000..a63587d89
--- /dev/null
+++ b/docs/hyperexecute-background-services.mdx
@@ -0,0 +1,85 @@
+---
+title: "Background Services"
+sidebarTitle: "Run Background Services"
+description: "This documentation will help you"
+keywords: ['hyperexecute background services']
+"og:description": "This documentation will help you"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Background Services is a feature of HyperExecute which is generally used to run the long running **Application Servers**. You can trigger the background services by using either the `background` or `backgroundDirectives` property in the [HyperExecute YAML](/support/docs/deep-dive-into-hyperexecute-yaml/#background) file.
+
+This feature is useful for the following cases:
+
+- Web Applications or Servers.
+- Running databases.
+- Providing file sharing or streaming services.
+- Running messaging or chat applications.
+- Providing APIs for other applications to use.
+
+## Enable Background Service
+There are two methods to enable the **Background Service** from the HyperExecute YAML file:
+
+### 1. Using `backgroundDirectives`
+
+```yaml
+backgroundDirectives:
+ shell: bash
+ commands:
+ - name: YOUR_SERVICE_NAME
+ command: npx static-server
+ - name: Database
+ command: mysql-server
+```
+- `shell`: defines the terminal it should use to run the background service.
+- `command`: specifies the command to be executed in the background.
+- `name`: specifies the name of your Background Service.
+
+### 2. Using `background`
+
+```yaml
+background:
+ - npx static-server
+ - mysql-server
+```
+{/* If background command fails, then the whole task will be marked as a fail */}
+
+## Background Service Logs
+
+To check the background service logs, follow the below mentioned steps:
+
+**Step 1:** After executing your job, go to the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/hyperexecute/jobs) to check the status of the job.
+
+**Step 2:** Click on the **Background Service** button.
+
+**Step 3:** Click on the desired **background service** you have triggered to check its logs.
+
+
+
+## Frequently Asked Questions
+
+
+
+ Yes, the service will run within the same Virtual Machine.
+
+
+
+ It initiates the execution of all background commands concurrently with the pre-stage and continues until the completion of post-run command execution.
+
+
+
+ No, the background service can only be accessed from within the same VM.
+
+
+
+ Yes, if the same set of background services, such as **`npm run server`**, are establishing HTTP servers on the same port, it is likely that one of the commands will encounter a binding issue and fail.
+
+
diff --git a/docs/hyperexecute-bidi-testing.mdx b/docs/hyperexecute-bidi-testing.mdx
new file mode 100644
index 000000000..087fb3a80
--- /dev/null
+++ b/docs/hyperexecute-bidi-testing.mdx
@@ -0,0 +1,112 @@
+---
+title: "Execute BiDi Framework Tests on HyperExecute"
+sidebarTitle: "BiDi"
+description: "Follow the instructions in this documentation, so that you can seamlessly execute XCUI tests on HyperExecute via TestMu AI."
+keywords: ['xcui', 'iOS', 'testmu ai', 'framework on testmu ai', 'testng', 'app testing', 'real devices']
+"og:description": "Follow the instructions in this documentation, so that you can seamlessly execute XCUI tests on HyperExecute via TestMu AI."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+**BiDi (Bi-Directional)** refers to the **WebDriver BiDi protocol**, a new standard from the W3C (World Wide Web Consortium). Unlike the traditional WebDriver protocol (which works in a request → response model), **WebDriver BiDi enables two-way communication between your test script and the browser in real time**.
+
+That means instead of only sending commands (like “click this element” or “navigate to this URL”), your test can also **subscribe to events happening inside the browser** as they occur — such as console logs, network requests, page lifecycle events, or JavaScript exceptions. In simple terms:
+- **Old WebDriver** = One-way communication (test script sends a command, browser replies).
+- **BiDi WebDriver** = Two-way communication (test script can also “listen” to the browser while interacting with it).
+
+BiDi brings modern automation capabilities that were missing in Selenium until now. Some key reasons to use it:
+- Real-time event monitoring
+- Network interception and mocking
+- Enhanced debugging
+- DOM and page lifecycle tracking
+- Ensures your tests are aligned with the latest W3C standards.
+
+[HyperExecute](/support/docs/getting-started-with-hyperexecute/) is an AI Native Test Orchestration Cloud Platform that empowers you to run **end-to-end** tests **quickly** and **efficiently**. It provides Just-in-Time (JIT) testing infrastructure with fast execution **speeds**, **smart orchestration**, and **detailed logs**.
+
+This guide details how to execute your **BiDi** tests on **HyperExecute** using [YAML 0.1](/support/docs/hyperexecute-yaml-parameters/)
+
+## Run a Sample Project
+### Step 1: Clone Sample Repository
+
+
+**BiDi repo**
+
+Download or Clone the BiDi sample from ’s GitHub Repository
+
+
+
+
+### Step 2: Download the CLI in your Project
+Download the HyperExecute CLI and copy it into the root folder of the downloaded sample repository.
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+
+### Step 3: Add the required Capabilities
+
+
+The `webSocketUrl` capability is set to `true` to enable BiDi support.
+
+
+```javascript title="wdio.testmu ai.config.js"
+
+capabilities: [{
+ "LT:Options": {
+ browserName: "chrome",
+ // highlight-next-line
+ webSocketUrl: true,
+ version: "latest",
+ platform: process.env.HYPEREXECUTE_PLATFORM || 'windows 10',
+ name: "HyperExecute BiDi Test",
+ build: "HyperExecute BiDi Test",
+ console: true,
+ }
+}],
+
+```
+
+### Step 4: Configure YAML in your Test Suite
+
+```yaml reference title="hyperexecute.yaml"
+https://github.com/LambdaTest/hyperexecute-bidi-sample/blob/main/yaml/hyperexecute-linux.yaml
+```
+
+### Step 5: Execute your Test Suite
+From the project root directory, execute the below CLI command in your terminal:
+
+
+**NOTE :** In case of MacOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config yaml/hyperexecute-linux.yaml
+
+```
+
+### Step 6: Monitor the Test Execution
+
+Visit the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/hyperexecute) and check your Job status.
+
+
+
+## Advanced Parameters
+Optimize your test pipeline using the following advanced features:
+
+- ✅ [Smart Test Splitting](/support/docs/hyperexecute-test-splitting-and-multiplexing/) – Automatically distribute tests across parallel runners
+- ⚡ [Fail Fast](/support/docs/hyperexecute-failfast/) – Stop test runs on the first failure
+- 📊 [Detailed Reports](/support/docs/hyperexecute-reports/) – Real-time terminal logs & rich test reports
+- 🔄 [Auto-Healing](/support/docs/hyperexecute-auto-healing/) – Automatically recover from certain failures
+
+
+For any query or doubt, please feel free to contact us via window.openLTChatWidget()}>**24×7 chat support** or you can also drop a mail to **support@testmuai.com**.
+
diff --git a/docs/hyperexecute-browser-list-api.mdx b/docs/hyperexecute-browser-list-api.mdx
new file mode 100644
index 000000000..265a49166
--- /dev/null
+++ b/docs/hyperexecute-browser-list-api.mdx
@@ -0,0 +1,190 @@
+---
+title: "How to List Supported Browser in HyperExecute via API"
+sidebarTitle: "List Browsers via API"
+description: "Find out how to list the browser used in hyperexecute using the BrowserList API"
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'How to List Supported Browser in HyperExecute via API']
+"og:description": "Find out how to list the browser used in hyperexecute using the BrowserList API"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+The Browser List API is a service provided by HyperExecute. It allows users to programmatically retrieve a list of all supported browsers and their versions on the HyperExecute platform. This information can be useful for compatibility checks and ensuring your web applications work across various browsers.
+
+It will provide you the details like:
+ - **platform name**
+ - **browsers name** and **versions**
+ - **resolutions**
+
+{/*
+- **Endpoint :** https://api.hyperexecute.cloud/v2.0/browsers**
+
+- **Request Type :** GET
+
+- **Authorization :** Basic
+ */}
+
+## API Endpoint and Authorization
+
+The Endpoint for the Browser List API is:
+
+```bash
+https://api.hyperexecute.cloud/v2.0/browsers
+```
+
+{/* ## Authentication
+To use the Browser List API, you will need an API key. You can obtain your API key by signing up for an account on HyperExecute and generating an API key from your account settings.
+
+Include your API key in the request headers using Basic Authentication as follows: */}
+
+```
+Request Type : GET
+Authorization: Basic
+```
+
+## Request
+The Browser List API supports a simple HTTP GET request to fetch the list of supported browsers
+
+```bash
+https://api.hyperexecute.cloud/v2.0/browsers
+```
+
+## Sample Response
+
+The response will be in JSON format, containing an array of objects representing each supported browser along with its versions.
+
+```bash
+{
+ "message": "",
+ "platforms": {
+ "desktop": [
+ {
+ "platform": "ubuntu 20",
+ "browsers": [
+ {
+ "name": "Chrome",
+ "version": "99.0"
+ },
+
+ {
+ "name": "Firefox",
+ "version": "99.0"
+ },
+
+ {
+ "name": "MicrosoftEdge",
+ "version": "canary"
+ },
+
+ {
+ "name": "Opera",
+ "version": "85.0"
+ },
+ {
+ "name": "Chrome",
+ "version": "latest"
+ },
+ {
+ "name": "Firefox",
+ "version": "latest"
+ },
+ {
+ "name": "MicrosoftEdge",
+ "version": "latest"
+ },
+ {
+ "name": "Opera",
+ "version": "latest"
+ }
+ ],
+ "resolutions": [
+ "1024x768",
+ "1280x800",
+ "1280x1024",
+ "1366x768",
+ "1440x900",
+ "1680x1050",
+ "1600x1200",
+ "1920x1200",
+ "1920x1080",
+ "2048x1536",
+ "2560x1440",
+ "1280x960"
+ ]
+ },
+ ]
+ },
+ "status": 200
+}
+```
+
+{/* ## Error Handling
+If there is an error with your request, the API will respond with an appropriate HTTP status code and an error message in the response body.
+
+Example Error Response: */}
+
+## Params
+
+```bash
+{
+ "platform": "windows 10" #optional
+ "stable": true #if passed we will return only stable version of browsers
+}
+```
+
+### Sample Response
+
+The response will be in JSON format, containing an array of objects representing each supported browser in **windows 10** only along with its versions.
+
+```bash
+{
+ "message": "",
+ "platforms": {
+ "desktop": [
+ {
+ "platform": "Windows 10",
+ "browsers": [
+ {
+ "name": "Firefox",
+ "version": "99.0"
+ },
+ {
+ "name": "Firefox",
+ "version": "100.0"
+ },
+ {
+ "name": "Firefox",
+ "version": "latest"
+ }
+ ],
+ "resolutions": [
+ "1024x768",
+ "1280x800",
+ "1280x1024",
+ "1366x768",
+ "1440x900",
+ "1680x1050",
+ "1600x1200",
+ "1920x1200",
+ "1920x1080",
+ "2048x1536",
+ "2560x1440"
+ ]
+ }
+ ]
+ },
+ "status": 200
+}
+```
+
+## cURL Command
+You can also use the `curl` command to trigger the following api:
+
+```
+curl --location --request GET 'https://api-hyperexecute.lambdatest.com/sentinel/v2.0/browsers'
+```
+
+## Conclusion
+
+The Browser List API simplifies the process of obtaining a comprehensive list of supported browsers and their versions on the HyperExecute platform. By using this information, you can ensure that your web applications are compatible across a wide range of browsers, leading to a better user experience for your audience.
diff --git a/docs/hyperexecute-build-mobile-apps-using-tools.mdx b/docs/hyperexecute-build-mobile-apps-using-tools.mdx
new file mode 100644
index 000000000..a54f10c09
--- /dev/null
+++ b/docs/hyperexecute-build-mobile-apps-using-tools.mdx
@@ -0,0 +1,60 @@
+---
+title: "Building Mobile Applications Using Tools"
+sidebarTitle: "Build APKs at Runtime"
+description: "Building Mobile Applications Using Tools"
+keywords: ['TestMu AI HyperExecute', 'gradle', 'maven', 'sdk', 'mobile apps', 'tools']
+"og:description": "Building Mobile Applications Using Tools"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Suppose you're working on an Android app using Gradle, and all of a sudden you realize that this project requires an older Java version and a specific Android SDK. Now, setting up a whole new environment in not a very convenient option.
+
+HyperExecute facilitate the development of mobile applications using various tools such as **Gradle**, **Maven**, etc. It provides a language and framework agnostic environment, supporting a wide range of tools and version combinations crucial for building **Android APKs** efficiently.
+
+## Building Apps with `runtime` Flag
+
+HyperExecute provides a [`runtime`](/support/docs/deep-dive-into-hyperexecute-yaml/#runtime) flag feature that dynamically downloads and installs required language and framework versions based on your needs. This removes the need for pre-installed environments on the execution machines.
+
+```bash
+runtime:
+ language: java
+ version: ${STATIC_DATA_1_JAVA_VERSION}
+ addons:
+ - name: "gradle"
+ version: "${STATIC_DATA_1_GRADLE_VERSION}"
+ - name: "android-sdk"
+ version: ${STATIC_DATA_1_ANDROID_SDK_VERSION}
+```
+
+## Leveraging DataJsonPaths for Dependency Management
+
+[`DataJsonPaths`](/support/docs/deep-dive-into-hyperexecute-yaml/#datajsonpath) helps to distribute data/configs over the VMs. In this you can create a json files and put configurations/data required for your suite as json array inside the file.
+
+This is useful when you have the project and you have to build it across different java, gradle and android-sdk versions.
+
+To provide multiple versions for each of these dependencies, the DataJson can be leveraged provided by HyperExecute.
+
+```bash
+[
+ {
+ "JAVA_VERSION": "11",
+ "ANDROID_SDK_VERSION": "24",
+ "GRADLE_VERSION": "7.5"
+ },
+ {
+ "JAVA_VERSION": "178",
+ "ANDROID_SDK_VERSION": "25",
+ "GRADLE_VERSION": "8"
+ },
+ {
+ "JAVA_VERSION": "20",
+ "ANDROID_SDK_VERSION": "32",
+ "GRADLE_VERSION": "8.4"
+ }
+]
+```
+
+HyperExecute empowers developers to build mobile applications effectively by providing a flexible and adaptable development environment. With features like dynamic dependency management, YAML parameter configuration, support for multiple dependency versions, and distributed configuration capabilities, HyperExecute streamlines the development process and enhances productivity.
diff --git a/docs/hyperexecute-cli-error.mdx b/docs/hyperexecute-cli-error.mdx
new file mode 100644
index 000000000..16ee5847c
--- /dev/null
+++ b/docs/hyperexecute-cli-error.mdx
@@ -0,0 +1,49 @@
+---
+title: "How to Debug your CLI Errors"
+sidebarTitle: "CLI Errors"
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'How to Debug a Failed Job']
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+This document will help you debug your failed job if you are facing any CLI issues.
+
+
+If you are encountering any error which is properly not detailed, it is recommend to use [**`verbose`**](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/#--verbose) mode in HyperExecute CLI command.
+
+
+## Symbolic Link Error
+
+This error will mark your Job as a **Lambda Error**.
+
+You can encounter this error when you try to upload the **node_modules** directory along with the payload to trigger your Job in HyperExecute. This error generally occurs with your Node.js projects. You must avoid doing this, as it will not only save storage space but also avoid potential issues with version control. The node_modules folder holds all the project dependencies, and adding it to the repository can cause unnecessary file duplication and increase the repository size.
+
+To resolve this issue, either you remove that directory or you simply add node_modules to the **.gitignore** file. This ensures you have a smooth development process without unnecessary hiccups.
+
+
+
+## Snooper Failed Error
+
+It's crucial to understand a specific characteristic of Gherkin – it exclusively supports the use of **Examples** with the **Scenario Outline**. If you come across an error, it likely indicates that the **Scenario** is being employed with **Examples** instead of the intended **Scenario Outline**. To resolve this, ensure that you use the appropriate structure, employing the Scenario Outline when incorporating Examples.
+
+
+
+
+
+## Authentication Error
+
+There may be cases where, when trying to connect to HyperExecute services, the CLI throws the following error:
+
+
+
+Now, to validate the connectivity and to make sure the **auth.hyperexecute.cloud** is reachable, you have to run a `scan` command in your CLI, as shown below. If the network scan fails, then you are required to whitelist the IP address.
+
+
+
+#### IPs to be Whitelisted
+
+| FQDN | Protocol:Port | Reason |
+|------|---------------|--------|
+|*.hyperexecute.cloud | Https:443 |HyperExecute’s registered wildcard domain to allow access to all HyperExecute’s services|
+|*.lambdatest.com | Https:443 | ’s registered wildcard domain to allow access to all ’s services (like auth, plan-validation) |
\ No newline at end of file
diff --git a/docs/hyperexecute-cli-errors.mdx b/docs/hyperexecute-cli-errors.mdx
new file mode 100644
index 000000000..bcab5fc8a
--- /dev/null
+++ b/docs/hyperexecute-cli-errors.mdx
@@ -0,0 +1,53 @@
+---
+title: "Debug your CLI Errors"
+sidebarTitle: "Fix CLI-Stage Errors"
+description: "This document will help you debug your failed job if you are facing any CLI issues."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'How to Debug a Failed Job']
+"og:description": "This document will help you debug your failed job if you are facing any CLI issues."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+This document will help you debug your failed job if you are facing any CLI issues.
+
+
+**If you are encountering any error which is properly not detailed, it is recommend to use [**`verbose`**](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/#--verbose) mode in HyperExecute CLI command.**
+
+
+
+## Symbolic Link Error
+
+This error will mark your Job as a **Lambda Error**.
+
+You can encounter this error when you try to upload the **node_modules** directory along with the payload to trigger your Job in HyperExecute. This error generally occurs with your Node.js projects. You must avoid doing this, as it will not only save storage space but also avoid potential issues with version control. The node_modules folder holds all the project dependencies, and adding it to the repository can cause unnecessary file duplication and increase the repository size.
+
+To resolve this issue, either you remove that directory or you simply add node_modules to the **.gitignore** file. This ensures you have a smooth development process without unnecessary hiccups.
+
+
+
+## Snooper Failed Error
+
+It's crucial to understand a specific characteristic of Gherkin – it exclusively supports the use of **Examples** with the **Scenario Outline**. If you come across an error, it likely indicates that the **Scenario** is being employed with **Examples** instead of the intended **Scenario Outline**. To resolve this, ensure that you use the appropriate structure, employing the Scenario Outline when incorporating Examples.
+
+
+
+
+
+## Authentication Error
+
+There may be cases where, when trying to connect to HyperExecute services, the CLI throws the following error:
+
+
+
+Now, to validate the connectivity and to make sure the **auth.hyperexecute.cloud** is reachable, you have to run a `scan` command in your CLI, as shown below. If the network scan fails, then you are required to whitelist the IP address.
+
+
+
+#### IPs to be Whitelisted
+
+| FQDN | Protocol:Port | Reason |
+|------|---------------|--------|
+|*.hyperexecute.cloud | Https:443 |HyperExecute’s registered wildcard domain to allow access to all HyperExecute’s services|
+|*.lambdatest.com | Https:443 | ’s registered wildcard domain to allow access to all ’s services (like auth, plan-validation) |
diff --git a/docs/hyperexecute-cli-faqs.mdx b/docs/hyperexecute-cli-faqs.mdx
new file mode 100644
index 000000000..d1427081f
--- /dev/null
+++ b/docs/hyperexecute-cli-faqs.mdx
@@ -0,0 +1,42 @@
+---
+title: "CLI FAQs"
+sidebarTitle: "CLI FAQs"
+description: "Explore HyperExecute CLI FAQs Downloading Test Artifacts, MacOS Verification, Test Run Steps & More! Get Quick Answers Here."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'FAQs']
+"og:description": "Explore HyperExecute CLI FAQs Downloading Test Artifacts, MacOS Verification, Test Run Steps & More! Get Quick Answers Here."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+#### 1. **Can HyperExecute CLI download test artifacts generated during execution?**
+
+ Yes, HyperExecute can download the artifacts generated during the test execution. In addition, HyperExecute has APIs to download artifacts for a particular job.
+
+***
+
+#### 2. **I am not able to open HyperExecute on MacOS because the developer is not verified. What do I do?**
+
+
+
+ The binary for Mac is unsigned. You might get a permission denied warning while executing HyperExecute on macOS and linux machines. To allow permissions you can use the following command: `chmod u+x ./hyperexecute`.
+ Thus, you might see a security popup on whether to allow the execution of the tool or not. You can allow it from your **System Preferences** → **Security & Privacy** → **General** tab.
+
+***
+
+#### 3. **Is there a way where I can follow all of the steps in my test run on HyperExecute?**
+
+ Every time you run a test via the [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/), a `hyperexecute-cli.log` file is generated. It is present in the parent directory of your test and contains the details of your entire test run.
+
+ This `hyperexecute-cli.log` file will also help you in debugging any issues with your tests. You can view the file and figure out exactly where your test run failed.
+
+ If you want more help with debugging your issues, you can always contact [support@testmuai.com](mailto:support@testmuai.com) and provide them with this file along with your Job ID.
+
+
+
+***
+
+For more information on the HyperExecute CLI, visit this [page](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/).
+
+>If you have more questions, then just give us a window.openLTChatWidget()}>shout and we will answer them for you.
diff --git a/docs/hyperexecute-cli-gui.mdx b/docs/hyperexecute-cli-gui.mdx
new file mode 100644
index 000000000..6e47a3573
--- /dev/null
+++ b/docs/hyperexecute-cli-gui.mdx
@@ -0,0 +1,277 @@
+---
+title: "HyperExecute GUI App"
+sidebarTitle: "Run Jobs via the GUI App (UnderPass)"
+description: "This documentation outlines the steps on how to trigger a job on hyperexecute using the underpass app - gui app for hyperexecute cli."
+keywords: ['TestMu AI', 'HyperExecute', 'TestMu AI HyperExecute', 'CLI', 'HyperExecute-GUI', 'test execute', 'hyperexecute job', 'automation']
+"og:description": "This documentation outlines the steps on how to trigger a job on hyperexecute using the underpass app - gui app for hyperexecute cli."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+**HyperExecute Graphical User Interface (GUI)** streamlines your test automation workflow and brings HyperExecute's power of test orchestration with the most intuitive way to interact. HyperExecute GUI makes testing simple, fast, and powerful. It abstracts all technical complexity to make **high-performance test execution available to everyone**.
+
+{/* The goal is to save your valuable time and effort to enable a more efficient testing process. */}
+
+## Why HyperExecute GUI?
+---
+**[HyperExecute](https://www.lambdatest.com/hyperexecute)** has been a **cornerstone for automation testing**, offering unparalleled flexibility with its YAML configurations and command-line interface. Now, with HyperExecute GUI, you can experience AI-powered test detection, set up test environments with simple clicks and run your tests without coding.
+
+
+
+## Prerequisites
+---
+
+**BETA**
+
+HyperExecute GUI is currently in **BETA** and supports the **Java TestNG Framework (with Java Version 11 or higher)**. We're actively working on expanding support for additional frameworks. If you have specific framework requests, please reach out to our window.openLTChatWidget()}>support team.
+
+
+
+**1. HyperExecute Access** : You need a account to use the HyperExecute GUI. If you don’t have one, [sign up](https://accounts.lambdatest.com/register?) now. Ensure your account includes HyperExecute access (free or paid plan) to get started.
+
+**2. UnderPass App Download** : Before getting started, download the UnderPass installer from your dashboard and install it on your system. Run the installer by following the on-screen instructions and launch the application.
+
+Currently HyperExecute GUI is a part of the ** UnderPass Application**. If you already have UnderPass app on your system, please update it to the latest version.
+
+
+**Download the GUI 🔗**
+
+You can download the app directly from your **HyperExecute Dashboard** or simply click the links below based on your operating system:
+ - **[Download for MacOS](https://downloads.lambdatest.com/underpass/master/UnderPass.dmg)**
+ - **[Download for Windows](https://downloads.lambdatest.com/underpass/master/UnderPass.exe)**
+ - **[Download for Linux](https://downloads.lambdatest.com/underpass/master/UnderPass.AppImage)**
+
+
+{/* ## Demo Walkthrough
+---
+For those who prefer a visual approach, we’ve created a comprehensive video tutorial to get you up and running quickly. All the steps taken in this video are explained in detail in the following step by step guide too.
+
+ */}
+
+## Getting Started
+---
+
+### Step 1: Select and Analyze Your Project
+Launch the application, log in with your credentials, and select your test project folder. The GUI analyzes your project i.e. the framework and language, network connectivity etc. Once the analysis completes, click **"Proceed"** to continue to the next step.
+
+{/* - Detect your testing framework and language
+- Verifies network connectivity (enabling a tunnel if needed) and checks URL access (prompting for proxy settings if required)
+- Set up a secure connection to your account */}
+
+
+**Sample Project 🔗**
+
+If you do not have a project handy, please feel free to use this **[Sample Project](https://github.com/LambdaTest/testng-selenium-hyperexecute-sample)** for trying out the GUI.
+
+
+
+
+
+**Common Issues & Solutions**
+
+The GUI will check the system and your project to ensure everything is ready. If any issues are found, you'll see clear instructions to resolve them. Some common issues faced by the users are:
+- **Missing programming language or package manager**: If your project uses a language or package manager that isn't installed on your computer, the GUI will guide you through installing it.
+- **Network connectivity issues**: If the GUI can't connect to servers, it will ask you to set up the necessary network settings through proxy.
+
+
+---
+
+### Step 2: Manage Configurations
+**A "Configuration"** is a saved combination of selected tests and execution settings that helps you create different run-profiles for easy management and operation.
+
+- **For new users:** A default configuration will be created to help you get started quickly. You can select the tests and run config settings as per your requirements.
+- **For existing users:** If you have existing configurations (version 0.2 YAML files) in the project, they'll be automatically imported, preserving all your settings. This ensures a smooth transition for existing HyperExecute users while providing a more intuitive interface.
+
+#### Quick Edit and Run
+At the configuration listing page you can find basic details and tags for each configuration. You can also **make quick changes and run the configuration** without going inside the configuration. There are a few other operations which you can access from this page like **Duplicate, Rename, Delete or Download the configuration as YAML.**
+
+
+
+
+A configuration is essentially a **complete test execution profile** that includes which specific tests to run from your test suite, all execution parameters (OS, concurrency, etc.), environment variables and other settings. Configurations eliminate the need to repeatedly select tests and adjust settings for common testing scenarios. For example, you might create separate configurations for smoke tests and full regression.
+
+
+ {/*
+At its current state, the GUI will not self-discover the tests according to rules stated in the YAML file while loading it. This feature will be available soon in next release.
+ */}
+
+---
+
+### Step 3: Discover and Select Tests
+Once you navigate to any Configuration, the app will automatically initiate Test Discovery. **Test Discovery is an automated process** that scans your project to identify and organize all test cases of your project. You can use either of the following methods for Tests Selection
+
+#### Manual Selection
+Allows you to browse and select tests individually or in groups. Tests can be organized by **Suite Tests, Files, Classes or Methods** for better visibility and easier navigation. You can select or deselect tests manually using checkboxes. This method works well for smaller test suites or when you need precise control over specific test cases.
+
+#### Query Selection
+For larger test suites, the query selection provides powerful filtering capabilities to **automatically select tests based on specified criteria**.
+For detailed instructions on creating and using advanced queries, refer to the [Build a Search Query](#build-a-search-query-in-the-gui) section below.
+
+ - **Orchestration Level:** When using query selection, you can define the orchestration level to determine how tests are **distributed and executed** across multiple parallel instances. This feature helps optimize execution time by intelligently grouping and distributing tests.
+
+
+
+#### Build a Search Query in the GUI
+
+##### What is a Query?
+
+Think of a query as a smart search filter that automatically finds and selects the exact tests you want to run. Instead of manually clicking through hundreds of test checkboxes, you simply describe what you're looking for using simple English-like instructions.
+
+**Key Benefits**
+
+- **Dynamic updates:** As new tests matching your criteria are added, they **automatically appear** in the results. This ensures you’re always working with the most up-to-date set.
+- **Precise test selection:** Combine multiple criteria like annotations, file locations and names to pinpoint exactly the tests you need for any given configuration.
+- **Cleaner workspace:** Only the relevant tests show up, keeping your test view streamlined and easy to navigate. Also, it helps decrease the manual errors.
+
+##### Understand the Query Structure
+Every query follows this simple pattern: `. ""`
+
+For example: `suiteTest.name = "LoginTest"` where,
+- `suiteTest` : what to look at (test within a suite)
+- `name` : what property (the name of the test)
+- `=` : how to compare (exactly equals)
+- `"LoginTest"` : what value (the specific name)
+
+##### Write Your First Query
+
+1. Navigate to your configuration details screen
+2. Click on the **"Test List"** tab
+3. Toggle to **"Query Selection"** mode
+4. You'll see a query input box with helpful dropdowns
+
+
+
+
+
+Let's build a query to find all the Suite (XML) Tests which have **login** in their name.
+
+###### Step 1: Choose What to Look At
+Start typing in the query box. You'll immediately see a dropdown with options:
+
+- `suite` : XML test suites
+- `suiteTest` : Tests within suites
+- `suiteClass` : Test classes within suites
+- `suiteMethod` : Individual test methods within suites
+- `fileClass` : Independent test classes (which are not part of any suite)
+- `fileMethod` : Methods in independent classes
+
+Let's choose `suiteTest` because we want to find tests within suites
+
+###### Step 2: Select a Property to Check
+After selecting `suiteTest`, another dropdown appears:
+
+- `name` : Name of the suite, class, or method
+- `path` : File path of the test in your project
+- `annotation_name` : Annotations like @Smoke, @Regression
+
+Select `name` or type it because we want to check test names. Your query now looks like `suiteTest.name`.
+
+###### Step 3: Pick a Comparison Operator
+Once you’ve typed or selected the property, a dropdown shows comparison options:
+
+- `=` : Equals (matches exactly)
+- `~` : Contains (matches part of the text in value)
+- `!~`: Not Contains (shouldn't contain part of the text in value)
+- `!=` : Not Equals (excludes exact matches)
+
+Choose `~` because we want names that contain "login". Your query now looks like: `suiteTest.name ~`
+
+###### Step 4: Enter the Value
+
+Type the value you’re looking for in quotes, like `"login"`. The app suggests values based on your project. With this, our query is complete and now looks like: `suiteTest.name ~ "login"`
+
+Press Enter and all the Suite Tests which contain the word "login" in their name will be listed down in a tree-like format. **This tree-like format** shows you the complete structure with the lowest entity showing the runnable test (`methods`, in case of TestNG).
+
+##### Add Multiple Conditions
+
+Want to be more specific? Add logical operators to combine conditions. After your first condition, you'll see a dropdown:
+
+- `AND` : Both conditions must be true
+- `OR` : Either condition can be true
+- `NOT` : Exclude what follows
+
+**Example:** Find login tests that are also smoke tests
+
+`suiteTest.name ~ "login" AND suiteTest.annotation_name ~ "Smoke"`
+
+##### Save the Query
+
+You can save your query in order to dynamically select tests whenever you come back to that specific Configuration. Queries are saved at **Configuration level** so that you can keep unique Configurations for different types of testing scenarios. For example, A configuration for smoke tests may have a saved query like `suiteTest.name ~ "Smoke"`.
+
+
+
+{/*
+**Coming Soon**
+
+Search within tests is not yet available on the GUI. We are working to make it available soon.
+ */}
+
+---
+
+### Step 4: Specify Run Config
+The **Run Config tab** in HyperExecute GUI offers an intuitive visual interface to configure your test environment and execution settings.
+You’ll find the basic preset configurations displayed just below your project name. If you need to modify or customize these settings, simply navigate to the Run Config tab and adjust your execution environment effortlessly — _no YAML editing required_.
+
+To learn about any configuration in detail, please search for the keyword in the **[HyperExecute YAML Documentation](/support/docs/deep-dive-into-hyperexecute-yaml)**. Please note that the GUI follows version 0.2 YAML parameters instead of discovery and runner commands as in version 0.1 YAML which you can find [here](/support/docs/hyperexecute-yaml-version0.2).
+
+---
+
+### Step 5: Run Tests and View Job
+Once you've set up your configuration by selecting the appropriate tests and reviewing your execution settings, you're ready to run your tests. The **"Run Tests"** button is available both from the configuration details screen and directly from the configurations listing page for quick access.
+
+A sidebar panel with job status and creation logs will appear with option to navigate to HyperExecute Dashboard to view more details. The HyperExecute-GUI displays the job logs in real-time as your tests run. Once complete, you can view the detailed test results in the HyperExecute Dashboard.
+{/* Click on the **View Job** button to get redirected to the job dashboard once the job is created. */}
+
+
+
+## Already Using HyperExecute via YAML?
+---
+If you’re a HyperExecute version 0.2 YAML user, you can easily import your existing version 0.2 YAML configurations into the GUI. Here’s how:
+
+{/* #### 1. Pop-Up on First Upload:
+ When you upload a project with YAML files, a **pop-up will automatically appear listing the existing YAMLs** in your project. Select a YAML file, and the app will import its settings for run config in the GUI.
+
+#### 2. Option to Import After Project Creation: */}
+Once your project is set up and you want to import a configuration using an existing YAML file :
+ - Go to the Configuration Listing page.
+ - Click on **"Import Config.”**
+ - Choose a YAML file from your project, and its settings will be imported to a new configuration.
+
+
+
+## FAQs
+---
+
+
+
+ No, Appium test support will be coming soon. Currently, the GUI is in beta and primarily supports TestNG framework with Selenium only.
+
+
+
+ Yes, you can use the project, but the associated test IDs will not be created. You would need to enable the "Screen Recording For Scenarios" key to record the entire scenario execution, with the video accessible from the HyperExecute dashboard. (This is applicable for non-Selenium based tests)
+
+
+
+ You would not be able to use such a project. Please ensure that each project is created from one folder only. We will be supporting this feature in the future.
+
+
+
+ Test discovery failures often stem from misconfigured environment variables or discovery flags when you may have private dependencies in your project. Here's how to troubleshoot. You can try adding environment variables or discovery flags in the GUI itself which may be required to resolve the dependencies. You will find two types of Environment Variables - Local and Remote. Local environment variables are used for local discovery and it is advisable to add these without any secret values since these are stored on local environment only.
+
+
diff --git a/docs/hyperexecute-cli-release-notes-0-2-249.mdx b/docs/hyperexecute-cli-release-notes-0-2-249.mdx
new file mode 100644
index 000000000..c4a4d1875
--- /dev/null
+++ b/docs/hyperexecute-cli-release-notes-0-2-249.mdx
@@ -0,0 +1,38 @@
+---
+title: "Version 0.2.249"
+sidebarTitle: "CLI v0.2.249"
+keywords: ['TestMu AI Hyperexecute','TestMu AI Hyperexecute help','TestMu AI Hyperexecute documentation','FAQs']
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+## Update CLI to the Latest Version - 0.2.249
+We’re excited to announce several key updates and enhancements in the latest version of our [CLI - 0.2.249](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/#download-the-hyperexecute-cli). You can update to the latest version to take advantage of the following improvements:
+
+### New Features and Enhancements
+- **Support for ProjectLink Payloads:** Added compatibility for projectLink-type sources.
+- **Maestro Framework Support:** Enhanced framework detection with default region handling.
+- **Capability Flags:** Introduced support for capability values in the [runson flag](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/#--runson).
+- **Cypress Integration:** Improved support for Cypress operations, including build configuration fixes.
+- **XCUI Enhancements:** Enabled XCUI test reports and increased dispatcher timeouts for XCUI jobs.
+
+### Bug Fixes
+- Fixed [`--use-zip`](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/#-z---use-zip) flag functionality for seamless execution.
+- Resolved GUI execution issues for C# projects.
+- Addressed issues with [inherited YAML configurations](/support/docs/hyperexecute-inherit-config/) and environment variable replacements.
+- Fixed nil map errors and streamlined email array replacement using variables.
+- Corrected XcTestPlanId configurations for improved iOS testing.
+
+### Performance Improvements
+- **Binary Updates:** Auto-update feature for binaries now functions without terminating the CLI process, with added support for Windows systems.
+- **Timeout Adjustments:** Increased app upload timeout to 5 minutes for smoother operations.
+
+### Miscellaneous Updates
+- Added support for Slack channel customization for alerting.
+- Improved discovery results with additional suite types for better test identification.
+- Moved essential files like `executeEngine.jar` to the project root for better accessibility.
+
+
+We strongly recommend updating to the [latest CLI version](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/#download-the-hyperexecute-cli) to leverage these enhancements, ensuring a smoother and more efficient experience.
+
\ No newline at end of file
diff --git a/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid.mdx b/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid.mdx
new file mode 100644
index 000000000..ed96141b2
--- /dev/null
+++ b/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid.mdx
@@ -0,0 +1,506 @@
+---
+title: "HyperExecute CLI - Run test on HyperExecute"
+sidebarTitle: "CLI Flags Reference"
+description: "Explains about HyperExecute CLI"
+keywords: ['testmu ai automation', 'testmu ai hyperexecute', 'hyperexecute automation grid', 'hyperexecute online', 'online hyperexecute', 'hyperexecute automation grid online', 'testmu ai hypterest tutorial', 'hyperexecute getting started', 'testmu ai hyperexecute getting started', 'hyperexecute automation testing', 'hyperexecute matrix execution', 'hyperexecute autosplit execution', 'hyperexecute auto-split execution']
+"og:description": "Explains about HyperExecute CLI"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+`HyperExecute CLI` is a command line interface that is required to run tests on HyperExecute. This page outlines all you need to know about the CLI and also explains about the different flags & functionalities supported by the HyperExecute CLI.
+
+
+HyperExecute CLI credentials (access keys, API tokens, etc.) are private and confidential. A system compromise may result in their unauthorized disclosure; therefore, you must secure the machine running the -HyperExecute CLI. Do not share or expose credentials in public code, repositories, or environments. In the event of a compromise, you are solely responsible for immediately revoking and regenerating the credentials. assumes no liability for any losses arising from failure to comply.
+
+
+
+## Download the HyperExecute CLI
+
+You can download the `HyperExecute CLI` for your OS from the links given below :
+
+| Platform | Download Link |
+| ---------| --------------------------- |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+
+## Verifying the Authenticity of the CLI
+To ensure the binary you’ve downloaded is genuine and has not been tampered with, you can verify its digital signature or code signing certificate. signs all official HyperExecute CLI releases for security and integrity assurance.
+
+
+
+
+You can verify the code signature of the binary using the `openssh` command. Download the [Signature](https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute.sig) and [Public Key](https://downloads.lambdatest.com/hyperexecute/linux/public_key.pem), keep it with your CLI, and paste the location in the below command:
+
+```bash
+openssl dgst -sha256 -verify -signature
+```
+
+
+
+
+
+
+You can verify the code signature of the binary using the `codesign` command. In your terminal run the following command:
+
+```bash
+codesign -dvvv
+```
+
+
+
+
+
+
+
+**Step 1:** Locate the downloaded CLI binary (e.g., hyperexecute.exe).
+**Step 2:** Right-click on the file and select Properties.
+**Step 3:** Go to the Digital Signatures tab.
+**Step 4:** Select the listed signature and click Details.
+**Step 5:** Click View Certificate → Details to inspect the certificate information.
+
+This certificate should display , Inc. as the verified publisher.
+
+
+
+
+
+
+## HyperExecute CLI Supported Flags
+
+HyperExecute CLI provides different command-line flags that let you control the HyperExecute platform as per your customised requirements. You can run `hyperexecute.exe --help` on your terminal to explore the different flags.
+
+
+
+The various flags that are supported are listed below.
+
+| Flags | Type | Description|
+|-------|------|------------|
+| [analyze](#analyze) | NA | Analyzes the language and environment supported in your project.|
+| [completion](#completion) | NA | Generates the autocompletion script for HyperExecute for the specified shell. |
+| [serve](#serve) | NA | Starts a server for HyperExecute info APIs |
+| [update](#update) | NA | Update the HyperExecute Binary Version |
+| [--add-testids](#--add-testids) | NA | Add test ids in job summary. |
+| [--auto-proxy](#--auto-proxy) | NA | Use detected system proxy.|
+| [--concurrency](#--concurrency) | Numerical | Indicates the number of concurrent sessions on HyperExecute. |
+| [--config](#--config) | string | Custom location for hyperexecute.yaml. |
+| [--disable-updates](#--disable-updates) | NA | Disable auto update |
+| [--download-artifacts](#--download-artifacts) | NA | Download the artifacts for a job. |
+| [--download-artifacts-path](#--download-artifacts-path) | string | Path of the directory to download artifacts for a job |
+| [--download-artifacts-zip](#--download-artifacts-zip) | NA | Download the artifacts for a job as a zip. |
+| [--download-logs](#--download-logs) | NA | Downloads console logs of your every tests of a job. |
+| [--download-report](#--download-report) | NA | Whether reports have to be downloaded or not. |
+| [--force-clean-artifacts](#--force-clean-artifacts) | NA | Download the updated artifacts of your job. |
+| [-h, --help](#-h---help) | NA | Help for hyperexecute. |
+| [--job-secret-file](#--job-secret-file) | string | Enter your secrets file path |
+| [-k, --key](#-k---key) | string | Access Key. |
+| [--labels](#--labels) | string | Incorporates the labels in your job. |
+| [--no-track](#--no-track) | NA | Stops updating the progress of the uplodaed jobs. |
+--onprem-host
+| [--preserve-payload](#--preserve-payload) | string | Preserves the job payload after its successful completion. |
+| [--runson](#--runson) | string | (comma-separated values of) OS on which the tests should run. |
+| [-s --scan](#-s---scan) | NA | Runs the network logs |
+| [--server-port](#--server-port) | string | Port number for the server (default "9191") |
+--static-data-filter
+| [-t, --target-directory](#-t---target-directory) | string | Directory where the test script has to be uploaded. |
+| [--target-path](#--target-path) | string | Upload the files and folders as part of the suite payload. |
+| [--tests-per-tunnel](#--tests-per-tunnel) | INT | Run the number of tests via tunnel. |
+| [-z, --use-zip](#-z---use-zip) | string | Path of the zip file that needs to be uploaded. |
+| [-u, --user](#-u---user) | string | username. |
+| [--vars](#--vars) | string | Method used to name keys. |
+| [--validate](#--validate) | NA | Validate HyperExecute YAML file. |
+| [--verbose](#--verbose) | NA | Logging of every proxy request to stdout. |
+| [--version](#--version) | NA | Version of the HyperExecute CLI. |
+
+### `analyze`
+This flag runs **HyperExecute Analyze**, which is a language and environment detection tool used to render every language and framework detail the user has in his project, which includes finding private dependencies.
+
+```bash
+hyperexecute analyze
+```
+
+
+
+***
+
+### `completion`
+This flag generates the autocompletion script for HyperExecute for the specified shell.
+
+```bash
+hyperexecute completion
+```
+
+
+
+***
+
+### `serve`
+This flag starts a server for HyperExecute info APIs.
+
+```bash
+hyperexecute --user USER_NAME --key ACCESS_KEY serve
+```
+
+***
+
+### `update`
+This flag updates the hyperexecute binary version.
+
+```bash
+hyperexecute update
+```
+
+***
+
+### `--add-testids`
+This flag will add the test ids of your job in the result.json file that gets generated after your test execution.
+
+```bash
+hyperexecute --add-testids
+```
+
+***
+
+### `--auto-proxy`
+This flag use detected system proxy. It identifies and sets proxies including http_proxy and https_proxy variables.
+
+```bash
+hyperexecute --auto-proxy
+```
+
+***
+
+### `--concurrency`
+This flag allows you to define the number of concurrent sessions running on HyperExecute. For more information on concurrency, go to [this page](/support/docs/hyperexecute-auto-split-strategy/).
+```bash
+--concurrency 2
+```
+***
+
+### `--config`
+
+This flag allows you to enter a custom location where you can download the HyperExecute YAML file. To learn more about the HyperExecute YAML, visit [this page](/support/docs/deep-dive-into-hyperexecute-yaml/).
+```bash
+--config "/home/users/work/yaml/"
+```
+***
+
+### `--disable-updates`
+This flag allows you to disable the auto updation of your HyperExecute binary.
+
+***
+
+### `--download-artifacts`
+This flag allows you to download all the test related results that are generated by your testing framework. You can use this key if you want to download the artifacts.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE --download-artifacts
+
+```
+
+
+- For Espresso with private devices HyperExecute can download user generated artefacts.**
+
+
+
+***
+
+### `--download-artifacts-path`
+In case you want the artifacts to be downloaded to a specific directory, please provide the exact path followed by the flag as shown in the example below.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE --download-artifacts-path "PATH_OF_YOUR_SPECIFIED_DIRECTORY"
+
+```
+
+***
+
+### `--download-artifacts-zip`
+If you want to download the zip file of the artifacts for a job.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE --download-artifacts-zip
+
+```
+
+***
+
+### `--download-logs`
+This flag allows you to download the detailed console logs of your entire job including your individual tests and your pre and discovery phase.
+
+***
+
+### `--download-report`
+This flag allows you to download all the test related results that are generated by your testing framework. You can use this key if you want to download the reports.
+
+***
+
+### `--force-clean-artifacts`
+This flag will download the new artifacts of your job and will store it into the `artifacts` folder. If you have previously downloaded artifacts, it will be renamed as `artifacts-old`.
+
+***
+
+### `-h, --help`
+You can run this command if you need any help in understanding the definition of the flags on the CLI itself. However, if you need any further assistance we're just a window.openLTChatWidget()}>**ping** away.
+```bash
+--help
+```
+***
+
+### `--job-secret-file`
+
+- This flag allows you to specify the Secrets file containing the necessary secrets (credentials, API keys, ) for a particular job.
+
+- The contents of this file will be accessible only within the scope of that specific job execution, enhancing security and streamlining secret management.
+
+- This eliminates the need to store secrets on the service account and prevents their accidental exposure through the `--vars` flag.
+
+```bash
+--job-secret-file
+```
+
+#### Sample Secret File
+
+```bash title="secretFile.txt"
+secret1=value1
+secret2=value2
+```
+
+
+**The secrets file contains highly sensitive information and must be strictly excluded from public exposure. Here's how to ensure its security:**
+
+**Store Outside the Repository (Recommended)**
+
+- Store the secrets file in a location outside your project repository altogether. This method is more secure as it automatically gets excluded from your code scripts zip file.
+
+**Exclude from Version Control**
+
+- Adding the relative path of the file (in which you have stored your secret data) to your [`.gitignore` or `.hyperexecuteignore`](/support/docs/hyperexecute-gitignore/) file. This prevents accidental inclusion of the file in your code repository.
+
+
+***
+
+### `-k, --key`
+The access key of your account. To find out how to retrieve your access key, visit [this page](/support/docs/hyperexecute-guided-walkthrough/#hyperexecute-dashboard).
+
+```bash
+
+ --key YOUR_LAMBDATEST_ACCESS_KEY
+
+```
+
+***
+
+### `--labels`
+This flag allows you to pass the labels of your Job.
+```bash
+--labels "testing"
+```
+***
+
+### `--no-track`
+You can track the progress of your uploaded jobs with HyperExecute. However, this flag allows you to opt out of receiving those updates.
+
+```bash
+--no-track
+```
+***
+
+### `--preserve-payload`
+This flag allows you to preserve the job payload after the job is completed successfully.
+```bash
+--preserve-payload
+```
+***
+
+### `--runson`
+This flag overrides the defined OS value in your YAML file's [`runson`](/support/docs/deep-dive-into-hyperexecute-yaml/#runson) flag. You can also define multiple values for OS (comma separated) in the case of [Matrix](/support/docs/hyperexecute-matrix-multiplexing-strategy) and [Hybrid](/support/docs/hyperexecute-hybrid-strategy/) mode execution.
+
+In case of [AutoSplit](/support/docs/hyperexecute-auto-split-strategy/) mode:
+
+```bash
+--runson linux
+```
+
+In case of [Matrix](/support/docs/hyperexecute-matrix-multiplexing-strategy) or [Hybrid](/support/docs/hyperexecute-hybrid-strategy/) mode:
+
+```bash
+--runson linux,win,win11,mac,mac13
+```
+
+***
+
+### `-s, --scan`
+This flag runs the network logs in your local machine console .
+
+```bash
+--scan
+```
+
+
+
+***
+
+### `--server-port`
+The `--server-port` flag is used to specify the port number that the HyperExecute server will use for communication. This can be useful if you need to run the server on a specific port due to network configurations or to avoid port conflicts with other applications.
+
+```bash
+--server-port=8080
+```
+
+***
+
+### `-t, --target-directory`
+{/* You can choose the directory where the test scripts have to be uploaded by using this flag. */}
+
+The `targetDirectory` option in the HyperExecute CLI specifies the directory where the output of the executed command will be stored. If this option is not specified, the output will be stored in the current working directory.
+
+```bash
+--target-directory "/home/users/work/yaml/scripts/"
+```
+***
+
+### `--target-path`
+{/* You can choose the files and folders that will be uploaded as a payload by using this flag. */}
+
+The `target-path` flag allows you to selectively upload specific files and folders as part of the suite payload. This can be used for streamlining the uploading process and ensuring that only relevant files are included in the payload.
+It can also be useful if a user wants to run tests in a monorepo for multiple services.
+
+```bash
+--target-path "src/test-suite/**"
+```
+***
+
+### `--tests-per-tunnel`
+
+This flag allows you to run a certain number of tests via tunnel. The default maximum number of tests is 10.
+
+```bash
+--tests-per-tunnel 5
+```
+***
+
+### `-z, --use-zip`
+This flag allows you to indicate the path of the zip file that needs to be uploaded for your tests to run.
+Let's say you already have a zipped payload that you want to upload, so you can provide the path of that payload and upload it.
+
+Whenever you zip your test files, it creates a folder, let's say **tests.zip**. Now, when this zip folder is unarchived, HyperExecute searches for a file named **`hyperexecute.yaml`**.
+
+In another scenario, suppose you first created a folder. Inside that folder, you put all your required test files and then zip that folder (say **folder.zip**). When this zip folder is unarchived, HyperExecute will again search for the **`hyperexecute.yaml`** file, which in this case won't be available as it will be inside the folder, which will throw an error.
+
+```bash
+--use-zip "/home/users/work/yaml/zip/"
+```
+***
+
+### `-u, --user`
+The username of your account.
+
+```bash
+
+ --user YOUR_LAMBDATEST_USERNAME
+
+```
+
+***
+
+### `--vars`
+This method allows you to name your variables. It helps you optimize the content of your YAML file by allowing for more flexibility.
+
+You can specify the email address for sharing [reports](/support/docs/hyperexecute-reports/) or [artifacts](/support/docs/hyperexecute-artifacts/) in a YAML configuration file using a variable. This allows you to dynamically set the email address and pass it via CLI, providing more flexibility than hardcoding the email address in the YAML file. Learn about this in [detail](/support/docs/hyperexecute-email-reports/#how-to-dynamically-set-your-email-address).
+```bash
+--vars "org=TestMu AI" --vars "product=HyperExecute" --vars "email=xyz@abc.com" --vars "email1=abc@xyz.com"
+```
+***
+
+### `--validate`
+The new `--validate` flag in the HyperExecute CLI allows you to quickly check the syntax and structure of your YAML file without running any tests. Simply pass the `--validate` flag with your YAML file, and the CLI will validate its structure and syntax. It will then return a success or error message, helping you identify if the file is correctly formatted or if there are any issues that need attention.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE --validate
+
+```
+
+***
+
+### `--verbose`
+This flag allows you to log all of your proxy requests to the output section (stdout).
+```bash
+--verbose
+```
+***
+
+### `--version`
+This flag indicates the version of HyperExecute CLI binary that you are running on your system.
+```bash
+--version
+```
+***
+
+## Trigger your Test from HyperExecute CLI
+
+In order to trigger your job on HyperExecute, execute the following command in your terminal. You will need to insert the name of your YAML file in place of the `RELATIVE_PATH_OF_YOUR_YAML_FILE` before running this command.
+
+ ```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+
+```
+
+
+**In case of macOS, if you get a permission denied warning while executing CLI, simply run `chmod u+x ./hyperexecute` to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General** tab.**
+
+
+
+
+**If you're running on a minimal alpine image, please make sure to install essential linux dependencies for HyperExecute CLI to work. **
+
+(An example with our sample repo has been given below):
+ ``` bash
+ apk add libc6-compat git bash
+ git clone https://github.com/LambdaTest/behave-selenium-hyperexecute-sample.git
+ cd behave-selenium-hyperexecute-sample/
+ wget https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute
+ chmod +x hyperexecute
+ ./hyperexecute --user --key --config yaml/win/behave_hyperexecute_autosplit_sample.yaml
+ ```
+
+
+## Running HyperExecute CLI in Quiet Mode
+
+Each time a job is run in Hyperexecute, a large number of logs are produced. These logs are sometimes beneficial for thorough debugging and analysis, it occasionally overwhelms Continuous Integration (CI) systems with an excessive amount of logs, especially when handling a large number of test executions.
+
+Hyperexecute provides a **"Quiet mode"** as a solution to this issue and to give users more control over the logging output. By only displaying significant updates during the test execution, this enables you to run tests with less logs.
+
+To enable the **Quiet Mode**, you need to paas these commands in your terminal and then trigger the command to execute your job.
+
+
+
+ ```yaml
+ env | grep CI # Used to check if the CI variable is set to true or not
+ export CI=true # If it's not set to true, then use this command to set as true
+ ```
+
+
+
+ ```yaml
+ env | grep CI # Used to check if the CI variable is set to true or not
+ set CI=true # If it's not set to true, then use this command to set as true
+ ```
+
+
+
+#### Output
+
+
+
+
+📕 Use the HyperExecute CLI's [Frequently Asked Questions](/support/docs/hyperexecute-cli-faqs/) to gain more knowledge about it.
+
diff --git a/docs/hyperexecute-csharp-use-cases.mdx b/docs/hyperexecute-csharp-use-cases.mdx
new file mode 100644
index 000000000..4699dfecd
--- /dev/null
+++ b/docs/hyperexecute-csharp-use-cases.mdx
@@ -0,0 +1,459 @@
+---
+title: "HyperExecute CSharp Use Cases"
+sidebarTitle: "C# Use Cases"
+description: "Discover the power of HyperExecute connected workflows and how testers or developers can leverage it for their daily autoamtion testing of their organization features."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'TestMu AI Projects', 'C Sharp', 'NUnit', 'Specflow']
+"og:description": "Discover the power of HyperExecute connected workflows and how testers or developers can leverage it for their daily autoamtion testing of their organization features."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+This guide provides a complete reference for integrating C# NUnit SpecFlow tests with HyperExecute, covering edge cases, solutions, YAML setup, artifact management, dynamic test discovery, and reporting.
+
+## 1. Autosplit
+### Edge Case
+Large test suites with hundreds or thousands of tests can leave some nodes idle while others are overloaded, resulting in wasted time and uneven execution.
+
+### Solution
+AutoSplit divides tests intelligently across nodes at file, module, or scenario level. Previously failed tests are prioritized for faster feedback. This ensures maximum concurrency usage and reduces test flakiness, enabling faster feedback loops for large BDD suites.
+
+```yaml title="hyperexecute.yaml"
+autosplit: true
+```
+
+### What Happens If We Don’t Use It
+
+- Inefficient node usage
+- Slower test execution
+- Flaky tests delay feedback
+- No control over test splitting
+
+---
+
+## 2. Matrix Setup
+### Edge Case
+Tests behave differently on various OS platforms. Running only on one OS may hide platform-specific bugs.
+
+### Solution
+The matrix runs tests concurrently on Mac, Windows, and Linux, detecting OS-specific issues like file paths, encoding, or browser behavior.
+
+```yaml title="hyperexecute.yaml"
+matrix:
+ os: [mac, win, linux]
+
+runson: ${matrix.os}
+```
+
+### What Happens If We Don’t Use It
+- Tests may pass on one OS but fail on others
+- Hidden bugs reach end users
+- Manual cross-OS testing required
+
+---
+
+## 3. Environment Variables (NuGet Paths)
+### Edge Case
+Parallel jobs sharing default NuGet caches may cause corrupted packages, race conditions, or build failures, especially in ephemeral environments or low disk space.
+
+### Solution
+Predefining NuGet paths ensures controlled caching, reliable builds across OSes, and efficient reuse of restored packages.
+
+```yaml title="hyperexecute.yaml"
+env:
+ NUGET_PACKAGES: '/home/ltuser/.nuget/packages/'
+ NUGET_HTTP_CACHE_PATH: '/home/ltuser/.local/share/NuGet/v3-cache'
+ NUGET_PLUGINS_CACHE_PATH: '/home/ltuser/.local/share/NuGet/plugins-cache'
+```
+
+### What Happens If We Don’t Use It
+- Random failures in parallel jobs
+- Slower builds
+- High network usage
+- Disk space issues
+- Inconsistent behavior across OSes
+
+---
+
+## 4. Pre Steps
+### Edge Case
+Dependencies may not be restored or projects may not build correctly if pre-steps are missing, causing test failures downstream.
+
+### Solution
+
+```yaml title="hyperexecute.yaml"
+pre:
+ - dotnet restore
+ - dotnet list OnlySpecTest.csproj package > packages.txt
+# - chmod 777 /tmp/NuGetScratch
+# - nuget locals all -clear
+ - dotnet build -c Release
+```
+
+- **dotnet restore** -> Restores NuGet packages
+- **dotnet list ... > packages.txt:** -> Saves package list for caching
+- **dotnet build -c Release:** -> Builds the project in Release mode
+- Optional commands handle permissions or cache clearing
+
+### What Happens If We Don’t Use It
+- Builds fail or produce outdated DLLs
+- Tests fail due to missing dependencies
+- Manual fixes required
+
+---
+
+## 5. Artifact Upload
+### Edge Case
+Without artifacts, failed tests provide no screenshots, logs, or reports for debugging, and outputs can be scattered in parallel executions.
+
+### Solution
+Artifacts centralize outputs like HTML reports and screenshots, enabling debug, traceability, and audit.
+
+```yaml title="hyperexecute.yaml"
+uploadArtefacts:
+ - name: Execution_Report
+ path:
+ - Report/**
+ - name: Execution_Screenshots
+ path:
+ - Screenshots/**/**
+```
+
+### What Happens If We Don’t Use It
+- No visual proof or logs
+- Debugging intermittent failures is hard
+- Manual reporting is required
+
+---
+
+## 6. Report Generation
+### Edge Case
+Partial or misconfigured reports can be unreadable, incomplete, or fail to merge in parallel executions.
+
+### Solution
+Generates human-readable HTML reports showing pass/fail, steps, screenshots, and aggregated results for stakeholders.
+
+```yaml title="hyperexecute.yaml"
+report: true
+partialReports:
+ location: Report/
+ type: html
+ frameworkName: specflow
+```
+
+### What Happens If We Don’t Use It
+- No centralized reporting
+- Harder to analyze test performance trends
+- Manual effort needed to share results
+
+---
+
+## 7. Test Discovery
+### Edge Case
+Static or incorrect discovery may skip new tests, misdetect test tags, or fail in parallel executions.
+
+### Solution
+Dynamic discovery automatically detects new @tags or features, enabling parallelization and reducing manual maintenance.
+
+```yaml title="hyperexecute.yaml"
+testDiscovery:
+ type: raw
+ mode: dynamic
+ command: grep -rni 'Features' -e '@' --include=*.feature | sed 's/.*@//'
+```
+
+### What Happens If We Don’t Use It
+- Manual selection of tests
+- New tests may never run
+- Reduced test coverage
+
+---
+
+## 8. testRunnerCommand
+### Edge Case
+Running all tests every time is inefficient, and category typos or missing attributes can prevent execution.
+
+### Solution
+Executes only tests with the specified Category. Supports parallelization and selective reruns.
+
+```yaml title="hyperexecute.yaml"
+testRunnerCommand: dotnet test --filter "(Category=$test)"
+```
+
+### What Happens If We Don’t Use It
+- All tests run every time
+- Slower pipelines
+- Increased build cost
+
+---
+
+## 9. Multiple Tag-Based Test Discovery
+### Edge Case
+Projects may have diverse tagging strategies, making standard discovery unreliable or incomplete.
+
+### Solution
+
+```yaml title="hyperexecute.yaml"
+testDiscovery:
+ type: raw
+ mode: dynamic
+ shell: bash
+ command: grep -E -w -R -A10 --include='*.feature.cs' ${tagname} AllInOneProject/features | grep 'public void' | cut -d' ' -f2- | awk '{print $3}' | sed 's/()$//' | sed 's/TestTearDown//g'
+```
+
+- Dynamically extracts test names based on tags
+- Ensures new tests are automatically included
+- Supports parallel execution and CI/CD pipelines
+
+### What Happens If We Don’t Use It
+- Missing tests due to inconsistent tagging
+- Manual updates required
+- Increased risk of regressions
+
+---
+
+## 10. Framework Version Compatibility Handling
+### Edge Case
+Different .NET versions require different build steps; incorrect handling causes build failures or runner crashes.
+
+### Solution
+Builds projects correctly based on target framework, ensuring compatibility with HyperExecute runners.
+
+**`.NET 6`+**: Use dotnet build in pre-steps
+**`.NET <6`**: Build locally and upload DLLs
+
+```yaml title="hyperexecute.yaml"
+C:\PROGRA~2\Micros~1\2019\Community\MSBuild\Current\Bin\MSBuild.exe /p:Configuration=Release /p:TargetFramework=net472 /t:restore
+```
+
+### What Happens If We Don’t Use It
+- Build failures
+- Outdated or incompatible DLLs
+- Test runner crashes
+
+---
+
+## 11. Private Dependencies (config.nuget)
+### Edge Case
+Projects depending on private NuGet feeds fail restore if credentials or feeds are not configured.
+
+### Solution
+Configures private feeds securely to ensure reliable dependency resolution across environments.
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### What Happens If We Don’t Use It
+- Restore failures (401 Unauthorized)
+- CI/CD errors
+- Manual debugging and inconsistent builds
+
+---
+
+## 12. Custom Test Runner Alternatives
+### Edge Case
+Some projects cannot run with dotnet test due to configuration or .NET version constraints.
+
+### Solution
+Alternative runner allows execution of targeted tests, respecting project-specific configurations.
+
+```yaml
+vstest.console.exe "GlobalPolaris\bin\Debug\net472\GlobalPolaris.dll" /Settings:GlobalPolaris\RunSettings.runsettings /TestCaseFilter:"FullyQualifiedName~$test"
+```
+
+### What Happens If We Don’t Use It
+- Tests may fail to execute
+- Build verification and pipelines are blocked
+
+---
+
+## 13. NUnit Console for Feature Tag Discovery
+### Edge Case
+Standard discovery may fail with complex NUnit tag setups.
+
+### Solution
+Uses NUnit console to explore feature tests by tags.
+```yaml
+& "C:\PROGRA~2\NUnit.org\nunit-console\nunit3-console.exe" "" --where="cat==$tag" --explore
+```
+
+### What Happens If We Don’t Use It
+- Tag-based tests are skipped
+- Partial coverage
+- Manual intervention required
+
+---
+
+## 14. Differential Upload Configuration
+### Edge Case
+Large test suites take long to upload; repeated full uploads waste time and bandwidth.
+
+### Solution
+Uploads only changed files, reducing upload time and network usage.
+
+```yaml title="hyperexecute.yaml"
+differentialUpload:
+ enabled: true
+ ttlHours: 300
+```
+
+### What Happens If We Don’t Use It
+- Slow uploads
+- Wasted resources
+- Longer pipeline durations
+
+---
+
+## 15. Certificate Management for Browser Authentication
+### Edge Case
+Browser tests requiring client certificates fail without proper installation.
+
+### Solution
+Installs certificates in browser environment for authenticated sessions.
+
+```yaml title="hyperexecute.yaml"
+%HYPEREXECUTE_WORKING_DIR%//Hyperexecute//cert_manager.exe --chrome -i atest089.pfx
+```
+
+### What Happens If We Don’t Use It
+- Browser authentication tests fail
+- Manual certificate setup required
+
+---
+
+## 16. Custom Status Reporting via CleanUp Function
+### Edge Case
+Test statuses may not be reported to HyperExecute properly, leading to incomplete dashboards.
+
+### Solution
+Custom function reports statuses for tracking and dashboards.
+
+```java title="test.java"
+public void CleanUp(string[] tagName, ScenarioExecutionStatus scenarioStatus, string scenarioName)
+{
+ string STATUS = scenarioStatus.ToString() switch
+ {
+ "OK" => "passed",
+ "UndefinedStep" => "skipped",
+ "TestError" => "failed",
+ _ => "others"
+ };
+ ((IJavaScriptExecutor)Properties.driver).ExecuteScript($"lambda-status={STATUS}");
+}
+```
+
+### What Happens If We Don’t Use It
+- Missing or inaccurate test reporting
+- Dashboard metrics incomplete
+
+---
+
+## 17. Custom SpecFlow Reporting Configuration
+### Edge Case
+Standard reports may not provide enough detail for complex SpecFlow tests.
+
+### Solution
+Generates custom reports with metadata and email notifications.
+
+```yaml title="hyperexecute.yaml"
+report: true
+partialReports:
+ location: GlobalPolaris/Reports
+ type: html
+ frameworkName: specflow-custom
+email:
+ to: ["example@lambdatest.com"]
+metaInfo: ["project-name:Global Polaris Regression","project-env:QA"]
+```
+
+### What Happens If We Don’t Use It
+- Reports lack detail
+- Stakeholders have limited visibility
+- Manual reporting required
+
+---
+
+## 18. File Level Discovery (DLL)
+### Edge Case
+Running tests on the wrong or outdated DLL causes failures or misses new tests.
+
+### Solution
+Ensures correct DLL is built and executed on the proper runner.
+
+```yaml title="hyperexecute.yaml"
+runson: win
+
+pre:
+ commands:
+ - dotnet restore
+ - dotnet build YourSolution.sln -c Release
+
+test:
+ commands:
+ - nunit3-console.exe "bin/Release/net6.0/YourProject.dll"
+```
+
+### What Happens If We Don’t Use It
+- Tests fail
+- New features not executed
+- Manual DLL verification required
+
+---
+
+## 19. Feature File Level Discovery (Matrix)
+### Edge Case
+All tests running together reduce parallelism and rerun flexibility.
+
+### Solution
+Run each feature individually to enable parallel execution and selective reruns.
+
+```yaml title="hyperexecute.yaml"
+matrix:
+ featurefile:
+ - "Features/Login.feature"
+ - "Features/Search.feature"
+ - "Features/Checkout.feature"
+
+test:
+ commands:
+ - nunit3-console.exe "bin/Release/net6.0/YourProject.dll" --where "cat == '$featurefile'"
+```
+
+### What Happens If We Don’t Use It
+- Parallelism lost
+- Slower execution
+- Rerunning failed features is difficult
+
+---
+
+## 20. Passing Arguments in HyperExecute
+### Edge Case
+Incorrect YAML quoting or missing result file paths cause unintended test runs or missing artifacts.
+
+### Solution
+Properly passing arguments ensures selective execution and saves results for artifact uploads.
+
+```yaml title="hyperexecute.yaml"
+test:
+ commands:
+ - nunit3-console.exe "bin/Release/net6.0/YourProject.dll" --where "cat == 'Regression'" --result="regression-result.xml"
+```
+
+### What Happens If We Don’t Use It
+- All tests may run accidentally
+- Slow pipelines
+- Missing artifacts for debugging
diff --git a/docs/hyperexecute-detox-testing.mdx b/docs/hyperexecute-detox-testing.mdx
new file mode 100644
index 000000000..3944a6774
--- /dev/null
+++ b/docs/hyperexecute-detox-testing.mdx
@@ -0,0 +1,134 @@
+---
+title: "Detox Testing on HyperExecute"
+sidebarTitle: "Detox"
+keywords: ['Detox', 'Detox automation', 'Detox testing', 'detox testing react native', 'detox automation testing', 'detox testmu ai', 'hyperexecute', 'hyperexecute detox testing', 'detox tests on hyperexecute', 'hyperexecute automation testing', 'HyperExecute React Native automation']
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+Detox is a popular end-to-end testing framework for React Native applications. This documentation will help you run your Detox tests on HyperExecute using your local system setup.
+
+## Run a Sample Project
+### Step 1: Clone Sample Repository
+
+
+**SAMPLE REPO**
+
+Download or Clone the Detox sample from 's GitHub Repository
+
+
+
+### Step 2: Download the CLI in your Project
+Download the HyperExecute CLI and copy it into the root folder of the downloaded sample repository.
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+
+### Step 3: Execute your Test Suite
+From the project root directory, execute the below CLI command in your terminal:
+
+```bash
+./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE
+```
+
+
+**NOTE:** In case of macOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+
+
+
+You've successfully triggered the Detox tests on HyperExecute. Visit the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/hyperexecute) and check your Job status.
+
+## Configure your own Project
+
+### Step 1: Download the CLI in your Project
+Download the HyperExecute CLI and copy it into the root folder.
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+
+### Step 2: Configure YAML in your Test Suite
+Use the sample YAML below to configure your execution:
+
+```yaml hyperexecute.yaml
+autosplit: true
+
+# Set the concurrency level for test execution (2 devices in parallel)
+concurrency: 1
+
+framework:
+ # Name of the test framework (raw in this case)
+ name: raw
+ args:
+ buildName: LT-Detox-Sample
+ deviceLogs: true
+ devices:
+ - .*-.*
+ disableReleaseDevice: true
+ env:
+ DETOX: true #detox
+ isRealMobile: true
+ mobileDC: true
+ platformName: android
+ # privateCloud: true # use this for private cloud
+ queueTimeout: 600
+
+ # Enable or disable video recording support
+ video: true
+
+# Make test status as HyperExecute job's status
+frameworkStatusOnly: true
+
+# job label for hyperexecute job
+jobLabel: ['raw','detox']
+
+# Pre-install required dependencies from pre-setup scripts
+pre:
+ - bash ./lambdatest/scripts/pre-setup.sh
+
+# Specify the target platform for test execution (Android in this case)
+runson: android
+
+# Test discovery configuration
+testDiscovery:
+ # Command to discover tests from the discovery.txt file
+ command: cat ./lambdatest/discovery.txt
+ # Test discovery mode is static
+ mode: static
+ # Test type is raw (custom test implementation)
+ type: raw
+
+# Command to run the tests using the testRunnerCommand
+testRunnerCommand: npm run $test
+
+# Define the version of the configuration file
+version: "0.2"
+```
+
+
+
+📘 To explore more configuration options and tailor settings to your project needs, check out the [YAML documentation](/support/docs/hyperexecute-yaml-parameters/).
+
+
+### Step 3: Monitor the Test Execution
+
+Visit the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/hyperexecute) and check your Job status.
+
+
+
+You can click on **View Test** from the **HyperExecute logs**, which will take you to the [App Automation dashboard](https://appautomation.lambdatest.com/build). There, you can access detailed **device logs**, **crash logs**, and **Metadata** for your test. You’ll also be able to watch a **video recording** of the Test sessions for better **debugging** and **analysis**.
+
+
+
+For any query or doubt, please feel free to contact us via window.openLTChatWidget()}>**24×7 chat support** or you can also drop a mail to **support@testmuai.com**.
+
\ No newline at end of file
diff --git a/docs/hyperexecute-emu-simu-devices-list.mdx b/docs/hyperexecute-emu-simu-devices-list.mdx
new file mode 100644
index 000000000..306b82ccc
--- /dev/null
+++ b/docs/hyperexecute-emu-simu-devices-list.mdx
@@ -0,0 +1,197 @@
+---
+title: "HyperExecute Emulator and Simulator Devices"
+sidebarTitle: "Supported Emulators & Simulators"
+description: "List of devices available on HyperExecute for Emulator and Simulator"
+keywords: ['hyperexecute device list', 'hyperexecute', 'testmu ai', 'emulator', 'simulator', 'hyperexecute dashboard']
+"og:description": "List of devices available on HyperExecute for Emulator and Simulator"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+HyperExecute supports a wide range of emulator and simulator devices for testing your applications. Below is the categorized list of available devices.
+
+## Emulators
+
+
+
+
+| Device Name | Category |
+|--------------------|----------|
+| Galaxy Note10 | Phone |
+| Galaxy Note10+ | Phone |
+| Galaxy S10 | Phone |
+| Galaxy S10 Lite | Phone |
+| Galaxy S10+ | Phone |
+| Galaxy S21 5G | Phone |
+| Galaxy Tab S5e | Tablet |
+| Galaxy Tab S6 | Tablet |
+| Galaxy Tab S7 | Tablet |
+| Galaxy Tab S7+ | Tablet |
+| LG Q7 | Phone |
+| Nokia G10 | Phone |
+| OnePlus 6 | Phone |
+| OnePlus 7 | Phone |
+| OnePlus 8 | Phone |
+| OnePlus 9 | Phone |
+| Pixel 3 | Phone |
+| Pixel 3 XL | Phone |
+| Pixel 3a | Phone |
+| Pixel 3a XL | Phone |
+| Pixel 4 | Phone |
+| Pixel 4 XL | Phone |
+| Pixel 4a | Phone |
+
+
+
+
+
+| Device Name | Category |
+|--------------------|----------|
+| Galaxy Note20 | Phone |
+| Galaxy Note20 Ultra| Phone |
+| Galaxy S20 | Phone |
+| Galaxy S20 FE | Phone |
+| Galaxy S20 Ultra | Phone |
+| Galaxy S20+ | Phone |
+| Galaxy S21 | Phone |
+| Galaxy S22 5G | Phone |
+| Galaxy Tab A 10.1 | Tablet |
+| Pixel 2 | Phone |
+| Pixel 2 XL | Phone |
+| Pixel 3 XL | Phone |
+| Pixel 3a | Phone |
+| Pixel 3a XL | Phone |
+| Pixel 4 | Phone |
+| Pixel 4 XL | Phone |
+| Pixel 4a | Phone |
+| Pixel 4a 5G | Phone |
+| Pixel 5 | Phone |
+| Pixel 5a 5G | Phone |
+
+
+
+
+
+| Device Name | Category |
+|------------------------|----------|
+| ASUS ZenFone 8 | Phone |
+| Galaxy A33 5G | Phone |
+| Galaxy A51 / A51 5G | Phone |
+| Galaxy A53 5G | Phone |
+| Galaxy A71 / A71 5G | Phone |
+| Galaxy A73 / A73 5G | Phone |
+| Galaxy A90 5G | Phone |
+| Galaxy Fold / Fold 5G | Foldable |
+| Galaxy Note10 / Note10 Lite / Note10+ | Phone |
+| Galaxy Note20 / Note20 Ultra | Phone |
+| Galaxy S10 / S10 Lite / S10+ / S10e | Phone |
+| Galaxy S20 | Phone |
+| Galaxy S21 / S21 FE / S21+ / S21 Ultra | Phone |
+| Galaxy S22 / S22+ / S22 Ultra | Phone |
+| Galaxy Tab S6 / S6 Lite / S6 5G | Tablet |
+| Galaxy Tab S7 / S7+ 5G | Tablet |
+| Galaxy Tab S8 / S8+ / S8 Ultra | Tablet |
+| Galaxy Z Flip / Z Flip 5G / Z Flip3 5G | Foldable |
+| Galaxy Z Fold2 / Z Fold3 5G | Foldable |
+| LG Velvet (5G / LTE) | Phone |
+| LG Wing 5G | Phone |
+| OnePlus 10 Pro | Phone |
+| OPPO Find X5 Pro | Phone |
+| Pixel 4 / 4 XL / 4a / 4a 5G | Phone |
+| Pixel 5 / 5a 5G | Phone |
+| Pixel 6 / 6 Pro | Phone |
+| Realme GT2 Pro | Phone |
+| Vivo X80 Pro | Phone |
+| Xiaomi 12 / 12 Pro | Phone |
+
+
+
+
+
+| Device Name | Category |
+|-------------------|----------|
+| ASUS ZenFone 8 | Phone |
+| Galaxy A33 5G | Phone |
+| Galaxy A51 / A51 5G | Phone |
+| Galaxy A53 5G | Phone |
+| Galaxy A71 / A71 5G | Phone |
+| Galaxy A73 / A73 5G | Phone |
+| Galaxy A90 5G | Phone |
+| Galaxy Fold / Fold 5G | Foldable |
+| Galaxy Note10 / Note10 Lite / Note10+ | Phone |
+| Galaxy Note20 / Note20 Ultra | Phone |
+| Galaxy S10 / S10 Lite / S10+ / S10e | Phone |
+| Galaxy S20 | Phone |
+| Galaxy S21 / S21 FE / S21+ / S21 Ultra | Phone |
+| Galaxy S22 / S22+ / S22 Ultra | Phone |
+| Galaxy Tab S6 / S6 Lite / S6 5G | Tablet |
+| Galaxy Tab S7 / S7+ 5G | Tablet |
+| Galaxy Tab S8 / S8+ / S8 Ultra | Tablet |
+| Galaxy Z Flip / Z Flip 5G / Z Flip3 5G | Foldable |
+| Galaxy Z Fold2 / Z Fold3 5G | Foldable |
+| LG Velvet (5G / LTE) | Phone |
+| LG Wing 5G | Phone |
+| OnePlus 10 Pro | Phone |
+| OPPO Find X5 Pro | Phone |
+| Pixel 4 / 4 XL / 4a / 4a 5G | Phone |
+| Pixel 5 / 5a 5G | Phone |
+| Pixel 6 / 6 Pro | Phone |
+| Realme GT2 Pro | Phone |
+| Vivo X80 Pro | Phone |
+| Xiaomi 12 / 12 Pro | Phone |
+
+
+
+
+
+| Device Name | Category |
+|-------------------|----------|
+| Pixel 6a | Phone |
+| Pixel 7 | Phone |
+| Pixel 7 Pro | Phone |
+| Pixel 4a | Phone |
+| Pixel 5 | Phone |
+| Pixel 5a 5G | Phone |
+
+
+
+
+
+## Simulators
+
+
+
+
+| Device Name | Category |
+|--------------------------------------|----------------|
+| iPhone SE (3rd generation) | Phone |
+| iPhone 14 | Phone |
+| iPhone 14 Plus | Phone |
+| iPhone 14 Pro | Phone |
+| iPhone 14 Pro Max | Phone |
+| iPad (9th generation) | Tablet |
+| iPad Pro (11-inch) (3rd generation) | Tablet |
+| iPad Pro (12.9-inch) (5th generation)| Tablet |
+| iPad Air (5th generation) | Tablet |
+| iPad mini (6th generation) | Tablet |
+
+
+
+
+
+| Device Name | Category |
+|--------------------------------------|----------|
+| iPhone SE (3rd generation) | Phone |
+| iPhone 15 | Phone |
+| iPhone 15 Plus | Phone |
+| iPhone 15 Pro | Phone |
+| iPhone 15 Pro Max | Phone |
+| iPad Air (5th generation) | Tablet |
+| iPad (10th generation) | Tablet |
+| iPad mini (6th generation) | Tablet |
+| iPad Pro (11-inch) (4th generation) | Tablet |
+| iPad Pro (12.9-inch) (6th generation)| Tablet |
+
+
diff --git a/docs/hyperexecute-enterprise-faqs.mdx b/docs/hyperexecute-enterprise-faqs.mdx
new file mode 100644
index 000000000..cb88f8261
--- /dev/null
+++ b/docs/hyperexecute-enterprise-faqs.mdx
@@ -0,0 +1,25 @@
+---
+title: "Enterprise FAQs"
+sidebarTitle: "Enterprise FAQs"
+description: "Get answers to all your queries about HyperExecute’s enterprise-level features, including SSO, dedicated support, custom setups, and more, enhancing your testing experience."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'FAQs']
+"og:description": "Get answers to all your queries about HyperExecute’s enterprise-level features, including SSO, dedicated support, custom setups, and more, enhancing your testing experience."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+#### 1. **Does HyperExecute provide enterprise level features?**
+
+ HyperExecute provides you with the best in class enterprise features including SSO, dedicated chat support, on-prem and dedicated cloud setups, custom retention period, usage analytics, advance access control, workflow management, and much more.
+
+***
+
+#### 2. **Can I use my own vault for testing with HyperExecute?**
+
+ HyperExecute enterprise version allows organizations to integrate their custom vaults with the HyperExecute testing infrastructure for greater flexibility.
+
+***
+
+>If you have more questions, then just give us a window.openLTChatWidget()}>shout and we will answer them for you.
diff --git a/docs/hyperexecute-environment-variable-setup.mdx b/docs/hyperexecute-environment-variable-setup.mdx
new file mode 100644
index 000000000..3597d5212
--- /dev/null
+++ b/docs/hyperexecute-environment-variable-setup.mdx
@@ -0,0 +1,90 @@
+---
+title: "HyperExecute Environment Variable Setup"
+sidebarTitle: "Install the CLI & Set Credentials"
+description: "Find out how to get access to Hyperexecute authentication credentials, fetching them from the Automation tab in your TestMu AI profile, and configuring them on Mac OSX/Linux, Windows systems."
+keywords: ['testmu ai automation', 'testmu ai environment variables', 'testmu ai setup', 'hyperexecute environment variables']
+"og:description": "Find out how to get access to Hyperexecute authentication credentials, fetching them from the Automation tab in your TestMu AI profile, and configuring them on Mac OSX/Linux, Windows systems."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+To provide you with a secure [cross-browser testing](https://www.lambdatest.com) environment on-cloud, we recommend integrating Authentication Credentials in your test scripts. This would allow our cloud servers to establish a secure connection between your local system and [HyperExecute](https://hyperexecute.lambdatest.com/). This document will help you understand how to set up HyperExecute environment variable for your respective operating system. This set up would also help authenticate your colleague's test cases when executed against an individual account.
+
+## Where to find Authentication Credentials?
+***
+
+ Authentication Credentials consists of two fields:
+
+1. Username
+2. Access Key
+
+>You can find these authentication credentials by either visiting the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/) or your [ Profile](https://accounts.lambdatest.com/detail/profile).
+
+#**Step 1:** Go to the right side Profile dropdown and select **Account Settings**.
+
+**Step 2:** Under Account Settings, go to **Password & Security**
+
+
+
+**Step 3:** You will find your LT Username and Access Key here, this would be required in order to trigger a Job using the [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/)
+
+
+**You can directly copy your Username and Access Key using shortcut key button.**
+
+
+
+
+>If you have more questions, then just give us a window.openLTChatWidget()}>shout and we will answer them for you.
+
+## Configuring Environment Variables on your Operating System
+
+Before the tests are run, please set the environment variables LT_USERNAME & LT_ACCESS_KEY from the terminal. The account details are available on your [ Profile](https://accounts.lambdatest.com/detail/profile) page.
+
+### Download the HyperExecute CLI
+
+The CLI is used for triggering the tests on HyperExecute. It is recommend to download the CLI binary on the host system and keep it in the root directory of the suite to perform the tests on HyperExecute.
+
+You can download the CLI for your desired platform from the below mentioned links:
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| MacOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+### Setup Environment Variable
+
+Now, you need to export your environment variables *LT_USERNAME* and *LT_ACCESS_KEY* that are available in the [ Profile page](https://accounts.lambdatest.com/detail/profile).
+
+Run the below mentioned commands in your terminal to setup the CLI and the environment variables.
+
+
+
+
+
+ ```bash
+
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+ ```powershell
+
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
diff --git a/docs/hyperexecute-espresso-testing.mdx b/docs/hyperexecute-espresso-testing.mdx
new file mode 100644
index 000000000..a05d9d22b
--- /dev/null
+++ b/docs/hyperexecute-espresso-testing.mdx
@@ -0,0 +1,318 @@
+---
+title: "Espresso Testing On HyperExecute"
+sidebarTitle: "Espresso"
+description: "Follow the instructions in this documentation, so that you can seamlessly execute Espresso tests on HyperExecute via TestMu AI."
+keywords: ['espresso', 'java', 'testmu ai java', 'framework on testmu ai', 'testng', 'app testing', 'real devices']
+"og:description": "Follow the instructions in this documentation, so that you can seamlessly execute Espresso tests on HyperExecute via TestMu AI."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+This page outlines how to execute your Espresso tests on HyperExecute with [YAML 0.2](/support/docs/hyperexecute-yaml-version0.2/)
+
+## Prerequisites
+
+To run the Tests on HyperExecute from your Local System, you are required:
+
+- Your [Username and Access key](/support/docs/hyperexecute-how-to-get-my-username-and-access-key/)
+- [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/) in order to initiate a test execution Job .
+- Setup the [Environmental Variable](/support/docs/hyperexecute-environment-variable-setup/)
+- [HyperExecute YAML](/support/docs/hyperexecute-yaml-version0.2/) file which contains all the necessary instructions.
+- An Android app (.apk or .aab file).
+
+## Step 1: Setup Your Test Suite
+
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample for the Espresso framework from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+
+## Step 2: Setup the CLI in your Test Suite
+
+After cloning / downloading the sample repo, you need to setup the CLI and the environment variables.
+
+### Download the HyperExecute CLI
+
+The CLI is used for triggering the tests on HyperExecute. It is recommend to download the CLI binary on the host system and keep it in the root directory of the suite to perform the tests on HyperExecute.
+
+You can download the CLI for your desired platform from the below mentioned links:
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| MacOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+
+### Setup Environment Variable
+
+Now, you need to export your environment variables *LT_USERNAME* and *LT_ACCESS_KEY* that are available in the [ Profile page](https://accounts.lambdatest.com/detail/profile).
+
+Run the below mentioned commands in your terminal to setup the CLI and the environment variables.
+
+
+
+
+
+ ```bash
+
+ export LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+export LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+
+ ```powershell
+
+ set LT_USERNAME="YOUR_LAMBDATEST_USERNAME"
+set LT_ACCESS_KEY="YOUR_LAMBDATEST_ACCESS_KEY"
+
+```
+
+
+
+
+## Step 3: Upload your Application
+
+Upload your _android_ application (.apk file) to the servers using our REST API. You need to provide your Username and AccessKey in the format `Username:AccessKey` in the cURL command for authentication.
+
+
+**Enter your local path of your android app instead of `` in the below cURL command.**
+
+
+
+```bash
+
+curl -u "YOUR_LAMBDATEST_USERNAME:YOUR_LAMBDATEST_ACCESS_KEY" -X POST "https://manual-api.lambdatest.com/app/upload/realDevice" -F "appFile=@""" -F "name="sampleApp""
+
+
+```
+
+
+Response of above cURL will be a **JSON** object containing the `App ID` of the format - `` and will be used in the next step.
+
+
+## Step 4: Upload your Test Suite
+
+Upload your **test suite (.apk file)** to the servers using our REST API by providing your **Username** and **AccessKey** in the format `Username:AccessKey` in the cURL command for authentication.
+
+Here is an example cURL request to upload your app using our REST API:
+
+
+**Enter your local path of your test suite app instead of `` in the below cURL command.**
+
+
+
+## Step 5: Configure YAML in your Test Suite
+
+Enter your `` and `` in the YAML file that you have fetched in the above step.
+
+
+
+
+
+```yaml
+---
+version: "0.2"
+globalTimeout: 150
+testSuiteTimeout: 150
+testSuiteStep: 150
+
+concurrency: 2
+
+runson: android
+
+autosplit: true
+
+report: true #to generate reports
+
+framework:
+ name: "android/espresso"
+ args:
+ buildName: "Espresso"
+ video: true
+ deviceLog: true
+ artifacts: true #to generate artifacts
+
+ # You can use either the appId (lt://APP1234567) or provide the path of the application using appPath. Both examples are given below.
+ appPath: proverbial_android.apk
+ testSuitePath: proverbial_android_expressotest.apk
+ # We have used the appPath and testSuitePath here.
+
+ # highlight-next-line
+ appId: lt://
+ # highlight-next-line
+ testSuiteAppId: lt://
+ # We have used the appId and testSuiteAppID here.
+
+ deviceSelectionStrategy: all
+ devices: ["Galaxy.*", "Pixel.*"]
+
+jobLabel: ['HYP', 'Espresso', 'Auto Sharding']
+```
+
+
+
+
+You can use either the `appId` and `testSuiteAppId` or provide the path of the application using `appPath` and `testSuitePath`. Both examples are given below.
+
+```yaml
+---
+version: "0.2"
+globalTimeout: 150
+testSuiteTimeout: 150
+testSuiteStep: 150
+
+concurrency: 2
+
+runson: android
+
+autosplit: false
+
+report: true #to generate reports
+
+framework:
+ name: android/espresso
+ args:
+ buildName: Espresso
+ video: true
+ deviceLog: true
+ artifacts: true #to generate artifacts
+
+ # highlight-next-line
+ appPath: proverbial_android.apk
+ # highlight-next-line
+ testSuitePath: proverbial_android_expressotest.apk # We have used the appPath and testSuitePath here.
+ # highlight-next-line
+ appId: lt://APP123456789
+ # highlight-next-line
+ testSuiteAppId: lt://APP123456789 # We have used the appId and testSuiteAppID here.
+ deviceSelectionStrategy: all
+ devices:
+ - Galaxy.*
+ - Pixel.*
+ shards:
+ mappings:
+ - name: shard1
+ strategy: class
+ values:
+ - com.lambdatest.proverbial .BrowserTest
+ # The strategy for this shard is based on "class".
+ # This shard will run all tests from the class com.lambdatest.proverbial .BrowserTest.
+ - name: shard2
+ strategy: package
+ values:
+ - com.lambdatest.proverbial
+ # The strategy for this shard is based on "package".
+ # This shard will run all tests that belong to the package com.lambdatest.proverbial .l.
+ - name: shard3
+ strategy: skipClass
+ values:
+ - com.lambdatest.proverbial .BrowserTest
+ # The strategy for this shard is to skip a specific class.
+ # This shard will avoid running tests from the class com.lambdatest.proverbial .BrowserTest.
+
+jobLabel: ['HYP', 'Espresso', 'Manual Sharding']
+```
+
+
+
+
+
+- The **uploadArtefact** flag is currently not available for Espresso framework tests.
+- To run **adb commands** in the **pre** and **post-steps**, include the following two flags in your YAML file: To execute it, you must have purchased an equivalent number of parallels for both HyperExecute and Real Device.
+
+```yaml
+privateCloud: true
+preservedDevice: true
+```
+
+
+## Step 6: Generate Reports and Artifacts
+To generate artifacts for your Espresso tests, add the `artifacts: true`, and `report: true` flag in your YAML file:
+
+```yaml
+report: true
+
+framework:
+ name: "android/espresso"
+ args:
+ artifacts: true
+ ...//
+```
+
+To download these artifacts in your local machine, you can pass the `--download-artifacts` and `--download-report` flag with the CLI command to execute the tests as shown in the next step.
+
+## Step 7: Execute your Test Suite
+
+
+**NOTE :** In case of MacOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+Run the below command in your terminal at the root folder of the project:
+
+```bash
+./hyperexecute --config RELATIVE_PATH_OF_YOUR_YAML_FILE --download-artifacts --download-report
+```
+
+OR use this command if you have not exported your username and access key in the step 2.
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config RELATIVE_PATH_OF_YOUR_YAML_FILE --download-artifacts --download-report
+
+```
+
+
+Visit the [HyperExecute Dashboard](https://hyperexecute.lambdatest.com/hyperexecute) and check your Job status.
+
+
+
+**Troubleshoot Guide**
+
+If you are stumbling upon errors during Espresso test execution, then refer to the [**Espresso Troubleshoot**](/support/docs/troubleshoot-espresso-tests/#sharded-espresso-errors) guide for detailed explanations to your common errors.
+
+
+## Additional Details
+
+### Sharding
+
+**Sharding** is a mobile test automation technique that distributes test cases across multiple real and virtual devices via parallel testing. It entails breaking down test suites into smaller subsets known as shards and running each shard concurrently on separate test execution environments.
+
+There are two types of Sharding:
+
+### Manual Sharding
+This feature enables users to manually specify shards along with their definitions, offering multiple strategies such as class, package, and more. By doing so, users can have greater flexibility and control over the sharding process.
+
+### Auto Sharding
+The system intelligently determines the distribution of tests across devices, employing specific criteria to optimize the testing process.
+
+
+- **When Shards are added :****
+
+ - If you are using the `deviceSelectionStrategy: all`,then in that case all the specified shards will be executed on every device available.
+
+ - If you are using the `deviceSelectionStrategy: any`, then in that case all the specified shards will be executed on just one device from the provided list.
+
+- **When Shards are not added :**
+ - If you are using the `deviceSelectionStrategy: all`, then in that case the tests will be executed on all mentioned devices in `.yaml` based on the concurrency.
+
+ - If you are using the `deviceSelectionStrategy: any`, then in that case all the specified tests will be executed on each device from the provided list, considering the concurrency setting.
+
+
+## Conclusion
+By following the instructions in this documentation, you can seamlessly execute the Espresso tests on HyperExecute, leveraging its secure cloud infrastructure, advanced features, and optimized test execution workflow.
diff --git a/docs/hyperexecute-failfast.mdx b/docs/hyperexecute-failfast.mdx
new file mode 100644
index 000000000..de3238f7b
--- /dev/null
+++ b/docs/hyperexecute-failfast.mdx
@@ -0,0 +1,55 @@
+---
+title: "FailFast"
+sidebarTitle: "Stop a Job Early (FailFast)"
+description: "Learn more about how to use HyperExecute's FailFast feature."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'FailFast Feature']
+"og:description": "Learn more about how to use HyperExecute's FailFast feature."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+HyperExecute's FailFast feature lets you to optimize your testing regimen by automatically aborting jobs that surpass a specified number of consecutive failures. This intelligent feature ensures that you receive prompt feedback and maintain a well-orchestrated testing process.
+
+
+
+## `maxNumberOfTests`
+
+The `maxNumberOfTests` flag serves as a parameter that determines the number of consecutive tests that need to be failed before the job is aborted automatically.
+
+For instance, if you set the `maxNumberOfTests` flag to 4, then your job will be aborted after four consecutive test failures. However, if three of your tests fail and the fourth one is passed, then the FailFast feature will reset and look for the next four consecutive tests that are failing.
+
+This allows you to speed up your test execution process and provide you with faster feedback.
+
+## Implementing FailFast
+
+To leverage the **FailFast** feature, simply incorporate the following command in your HyperExecute YAML file:
+
+```yaml
+failFast:
+ maxNumberOfTests: 2
+```
+
+
+**To apply `failFast` at the **scenario** level instead of the default test level, set the `level: scenario` in the YAML configuration.**
+
+```yaml
+failFast:
+ maxNumberOfTests: 2
+ level: scenario
+```
+
+
+
+**NOTE :** You can specify `failFast` at either the test level or scenario level, depending on your requirements. Both configurations will work, but can lead to unexpected results, only one should be used at a time.
+
+
+
+***
+
+For a deeper understanding of the HyperExecute YAML and its versatile features, we invite you to explore our dedicated [HyperExecute YAML documentation](/support/docs/deep-dive-into-hyperexecute-yaml/) page. This resource-rich section provides valuable insights to empower your testing endeavors.
+
+***
+
+>If you have more questions, then just give us a window.openLTChatWidget()}>shout and we will answer them for you.
diff --git a/docs/hyperexecute-faqs.mdx b/docs/hyperexecute-faqs.mdx
new file mode 100644
index 000000000..87b1939e6
--- /dev/null
+++ b/docs/hyperexecute-faqs.mdx
@@ -0,0 +1,30 @@
+---
+title: "HyperExecute FAQs"
+sidebarTitle: "FAQs"
+description: "Get quick answers to all your HyperExecute queries with our comprehensive FAQs!"
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'FAQs']
+"og:description": "Get quick answers to all your HyperExecute queries with our comprehensive FAQs!"
+noindex: true
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+If you have more questions, then just give us a window.openLTChatWidget()}>shout and we will answer them for you.
+
diff --git a/docs/hyperexecute-feature-faqs.mdx b/docs/hyperexecute-feature-faqs.mdx
new file mode 100644
index 000000000..8db864044
--- /dev/null
+++ b/docs/hyperexecute-feature-faqs.mdx
@@ -0,0 +1,56 @@
+---
+title: "Features FAQs"
+sidebarTitle: "Features FAQs"
+description: "Explore HyperExecute Feature FAQs | Get comprehensive answers and insights to enhance your understanding of TestMu AI's HyperExecute feature. Maximize efficiency and effectiveness in your testing processes."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'FAQs']
+"og:description": "Explore HyperExecute Feature FAQs | Get comprehensive answers and insights to enhance your understanding of TestMu AI's HyperExecute feature. Maximize efficiency and effectiveness in your testing processes."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+#### 1. **How can I integrate HyperExecute with other CI/CD platforms?**
+
+ Since HyperExecute is operated using a universal CLI, it essentially takes two lines of terminal commands to integrate HyperExecute with any CI/CD platform. You need to download the CLI and trigger it to do this.
+
+***
+
+#### 2. **How is HyperExecute different from other testing clouds?**
+
+ While other testing platforms throw infrastructure at the users to run their tests, HyperExecute is a smart orchestration cloud where the platform decides the best execution plan to finish the jobs in the least amount of time. HyperExecute accomplishes this by distributing tests smartly on available resources, providing other features, such as, retrying failed scenarios, automatic reordering and more. HyperExecute acts as a co-pilot for developers to run and triage their tests as fast as possible.
+
+***
+
+#### 3. **What smart CI features does HyperExecute provide?**
+
+ HyperExecute provides you with the option to run pre and post steps that allow users to run any command before and after running tests on every VM, define custom environment variables, deep dependency caching, pick a specific version of language runtimes, artifacts management, and more. HyperExecute allows you to move your sophisticated pipelines for end to end testing completely. Triggering and execution of tests happens entirely on HyperExecute infrastructure and frees your CI or local system to do other meaningful tasks.
+
+***
+#### 4. **Can I test my private web applications on HyperExecute?**
+
+ Absolutely. HyperExecute allows multiple provisions to test private applications by the following directives: automatically running tunnels using the CLI, and by creating dedicated NAT for organizations that can be whitelisted by their firewalls. We have users who are able to run VPN clients in the pre steps before starting their tests which allows them to securely connect to their private workloads.
+
+***
+
+#### 5. **Can I do geolocation testing on HyperExecute?**
+
+ Yes, HyperExecute provides geolocation testing by providing capabilities in selenium, playwright, and cypress tests. All the geolocation testing features available on the standard platform are available on HyperExecute.
+
+***
+
+#### 6. **Can HyperExecute run my tests on virtual machines with custom specifications?**
+
+ Yes, with the enterprise version, HyperExecute provides directives to use custom virtual machines based on the HyperExecute base virtual machine image. This allows for greater flexibility to run customer frameworks.
+
+***
+
+#### 7. **Can I use HyperExecute to run test cases on Microsoft Excel?**
+
+ Yes, you can configure HyperExecute to run your Microsoft Excel test cases. However, this feature is only available on request at this moment. Visit [our documentation](/support/docs/hyperexecute-winapp-integration/) for this feature or contact support@testmuai.com to know more.
+
+***
+
+For more information on HyperExecute features, visit this [page](/support/docs/key-features-of-hyperexecute/).
+
+>If you have more questions, then just give us a window.openLTChatWidget()}>shout and we will answer them for you.
diff --git a/docs/hyperexecute-gattling-testing.mdx b/docs/hyperexecute-gattling-testing.mdx
new file mode 100644
index 000000000..26efff65f
--- /dev/null
+++ b/docs/hyperexecute-gattling-testing.mdx
@@ -0,0 +1,166 @@
+---
+title: "Gatling Automation on HyperExecute"
+sidebarTitle: "Gatling"
+description: "Learn how to run Selenium automation tests on HyperExecute using the Gatling framework"
+keywords: ['Gatling', 'Gatling selenium', 'Gatling Java Selenium', 'Gatling automation testing', 'selenium webdriver Gatling', 'selenium Gatling testing tutorial', 'Gatling Java Selenium framework', 'testmu ai Gatling', 'frameworks on testmu ai', 'hyperexecute', 'hyperexecute Gatling testing', 'hyperexecute Gatling testing', 'hyperexecute automation testing', 'HyperExecute Selenium automation']
+"og:description": "Learn how to run Selenium automation tests on HyperExecute using the Gatling framework"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+import { GitHubButton } from '/snippets/GitHubButton.mdx';
+
+
+Gatling is an open-source load and performance testing framework designed for testing web applications. It uses a powerful Scala-based DSL to define test scenarios and is capable of simulating thousands of concurrent users, making it ideal for stress and performance testing.
+
+## 🚀 Why Choose HyperExecute for Gatling Performance Testing?
+While Gatling is powerful on its own, running large-scale performance tests using traditional setups often introduces significant bottlenecks:
+
+### ⚠️ Common Challenges with Traditional Runners
+- **Infrastructure Limitations:** Tests run sequentially or on underpowered machines, leading to long execution times.
+- **Manual Setup & Maintenance:** Developers must handle environment configuration, dependency resolution, and runtime orchestration manually.
+- **Limited Scalability:** Scaling tests across multiple machines requires complex setup and resource coordination.
+- **Debugging Overhead:** Analyzing failures or performance issues often involves sifting through scattered logs and inconsistent outputs.
+
+### ✅ How HyperExecute Solves These Challenges
+’s HyperExecute platform is purpose-built to streamline and supercharge your Gatling test execution:
+
+- **⚡ Smart Test Distribution:** Automatically splits and runs tests across multiple machines for faster execution and optimal resource utilization.
+- **🧪 Isolated, Reproducible Environments:** Each test job runs in its own isolated environment with managed dependencies for consistent results.
+- **📊 Built-in Reporting & Artifact Management:** Uploads Gatling reports and logs as artifacts that can be easily accessed and analyzed post-run.
+- **🔁 Built-in Retry & Stability Handling:** Supports automatic retries for failed scenarios to minimize false negatives and flakiness.
+- **🔍 Deep Debugging Insights:** Rich logs, structured output, and centralized monitoring help you trace performance bottlenecks with ease.
+
+### 🚀 Result: Scalable, Reliable, and Faster Gatling Test Cycles
+By integrating Gatling with HyperExecute, you can move beyond traditional limitations and run large-scale load tests with speed, precision, and confidence. This guide provides a structured approach to integrating the Gatling performance testing framework with the HyperExecute platform.
+
+## Prerequisites
+To run the Tests on HyperExecute from your Local System, you are required:
+
+- Your [Username and Access key](/support/docs/hyperexecute-how-to-get-my-username-and-access-key/)
+- [HyperExecute YAML](/support/docs/hyperexecute-yaml-version0.2/) file which contains all the necessary instructions.
+- [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/) in order to initiate a test execution Job .
+- Setup the [Environmental Variable](/support/docs/hyperexecute-environment-variable-setup/)
+
+## Run a Sample Project
+### Step 1: Download Project
+You can use your own project to configure and test it. For demo purposes, we are using the sample repository.
+
+
+**Sample repo**
+
+Download or Clone the code sample for the Gatling Performance Testing from the GitHub repository to run the tests on the HyperExecute.
+
+
+
+
+### Step 2: Download the CLI in your Project
+Download the HyperExecute CLI and copy it into the root folder of the downloaded sample repository.
+
+| Platform | HyperExecute CLI |
+| ---------| ---------------- |
+| Linux | https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute |
+| Windows | https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe |
+| macOS | https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute |
+
+### Step 3: Configure your hyperexecute.yml file
+The core of HyperExecute configuration lies in the `hyperexecute.yaml` file. Let’s understand how it is constructed — step by step:
+
+#### 1. Define Test Environment and Execution Strategy
+The first step is to define the environment your tests will run on using the runson parameter. You can also configure intelligent parallelization and test exit conditions.
+
+```yaml
+version: 0.1
+runson: linux # OS to run the tests (e.g., linux, win)
+autosplit: true
+concurrency: 1 # Defines the number of test sessions to run concurrently
+scenarioCommandStatusOnly: true
+```
+
+#### 2. Dependency Resolution with Maven
+Before running the actual performance test, ensure all project dependencies are resolved locally for a reproducible build. This step pulls all required Maven dependencies to a local directory (.m2), ensuring environment consistency.
+
+```yaml
+pre:
+ - mvn -Dmaven.repo.local=./.m2 dependency:resolve
+```
+
+#### 3. Configure Test Discovery (Optional)
+Test discovery determines what files or test suites should be run. You can customize this to dynamically scan simulation classes.
+
+```yaml
+testDiscovery:
+ type: raw
+ mode: static
+ command: echo "Test"
+```
+The `command` is a placeholder here. In advanced setups, you can provide a script to programmatically discover test files.
+
+#### 4. Configure the Test Execution Command
+Specify the command that runs your Gatling tests via Maven:
+
+```yaml
+testRunnerCommand: mvn gatling:test
+```
+
+#### 5. Add Background Services (Optional)
+If your test depends on a backend server or application under test, you can spin it up in the background:
+
+```yaml
+background:
+ - mvn spring-boot:run -Dspring-boot.run.main-class=dev.simonverhoeven.gatlingdemo.GatlingDemoApplication || true
+```
+
+When `autosplit` is enabled, this command can be intelligently distributed across runners.
+
+#### 6. Upload Test Reports
+Once the test completes, use uploadArtefacts to store Gatling reports:
+
+```yaml
+uploadArtefacts:
+ - name: TestReport
+ path:
+ - target/gatling/**
+```
+
+These will be visible in the HyperExecute logs UI after the run.
+
+#### 7. Add Retry Logic (Optional)
+You can automatically retry failed tests to avoid flakiness.
+
+```yaml
+retryOnFailure: true
+maxRetries: 1
+```
+
+Here is a complete working YAML configuration that runs Gatling performance tests on linux runners via HyperExecute:
+
+```yaml reference title="hyperexecute.yaml"
+https://github.com/prateekLambda/Gatling-performance-hyperexecute/blob/main/HYE.yaml
+```
+
+
+📘 For a deeper understanding and project-specific configurations, check out the [YAML documentation](/support/docs/hyperexecute-yaml-parameters/).
+
+
+### Step 4: Execute your Test Suite
+From the project root directory, execute the below CLI command in your terminal:
+
+```bash
+
+ ./hyperexecute --user YOUR_LAMBDATEST_USERNAME --key YOUR_LAMBDATEST_ACCESS_KEY --config hyperexecute.yaml
+
+```
+
+
+**NOTE :** In case of macOS, if you get a permission denied warning while executing CLI, simply run **`chmod u+x ./hyperexecute`** to allow permission. In case you get a security popup, allow it from your **System Preferences** → **Security & Privacy** → **General tab**.
+
+
+
+
+
+## Advanced Parameters
+Optimize your test pipeline using the following advanced features:
+
+- ✅ [Smart Test Splitting](/support/docs/hyperexecute-test-splitting-and-multiplexing/) – Automatically distribute tests across parallel runners
+- ⚡ [Fail Fast](/support/docs/hyperexecute-failfast/) – Stop test runs on the first failure
+- 📊 [Detailed Reports](/support/docs/hyperexecute-reports/) – Real-time terminal logs & rich test reports
diff --git a/docs/hyperexecute-general-faqs.mdx b/docs/hyperexecute-general-faqs.mdx
new file mode 100644
index 000000000..0517fe020
--- /dev/null
+++ b/docs/hyperexecute-general-faqs.mdx
@@ -0,0 +1,124 @@
+---
+title: "FAQs"
+sidebarTitle: "General FAQs"
+description: "Explore HyperExecute General FAQs Testing Frameworks, Configurations, and More! Get answers to your questions about HyperExecute's features and capabilities."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'FAQs']
+"og:description": "Explore HyperExecute General FAQs Testing Frameworks, Configurations, and More! Get answers to your questions about HyperExecute's features and capabilities."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+#### 1. **Which testing frameworks does HyperExecute support?**
+
+ Though HyperExecute has a [very deep support](/support/docs/hyperexecute-supported-languages-and-frameworks/) for Selenium, Cypress, Playwright, CDP, Taiko and other web browser testing frameworks, nothing stops it from running any other tests over the HyperExecute platform using YAML. Core orchestration features and real time logs are native to the platform and will be available over any kind of testing.
+
+***
+
+#### 2. **Can I run a specific command before running tests on HyperExecute?**
+
+ HyperExecute provides you with smart CI features where you can run any command before and after running tests using pre and post steps. Common use cases include, building/ compiling binaries, downloading dependencies, starting services in the background or any other arbitrary command.
+
+***
+
+#### 3. **Do I need to change my code to run my tests on HyperExecute?**
+
+ No code or logic changes have to be done in order to run your end to end tests on HyperExecute. HyperExecute requires a YAML configuration file to determine which tests to run and configure other settings. This YAML file can be created using an online YAML generator, hosted on the HyperExecute onboarding page.
+
+***
+
+#### 4. **Where will HyperExecute run my tests?**
+
+ HyperExecute takes your test scripts and places them in virtual machines having all the components required to run your tests and collect logs and metrics. These virtual machines are hosted by HyperExecute in its secure cloud environment. HyperExecute is also available on dedicated and private clouds where virtual machines can run in your personal cloud accounts.
+
+***
+
+#### 5. **How to use HyperExecute?**
+
+ Tests are triggered on HyperExecute using [HyperExecute CLI](/support/docs/getting-started-with-hyperexecute/) using a YAML file to configure the executing settings including target OS, concurrency and other CI level information. This YAML file can be generated easily using a web based YAML generator that supports multiple [languages and frameworks](/support/docs/hyperexecute-supported-languages-and-frameworks/). As a user you need to focus on writing tests and running the CLI with YAML, everything else is taken care of by the orchestration platform.
+
+***
+
+#### 6. **Why is HyperExecute faster than other end to end testing platforms?**
+
+ Traditional end to end testing platforms add a lot of latency in test execution due to the fragmented components by adding multiple hops. Each and every request has to travel through multiple hops before it can be served by the application under test. This doesn’t just slow tests down, but adds a lot of platform-induced flakiness. HyperExecute puts all the components and the test script in a single isolated environment to run the tests in the fastest and the most efficient way.
+
+***
+
+#### 7. **How does HyperExecute help me debug my tests faster?**
+
+ HyperExecute collects every possible log, including terminal logs, selenium and more (for every single test), and stores them separately from each other. These isolated logs ensure that the end user is not spending time in filtering useful logs and focuses on getting the insights from the logs as fast as possible. HyperExecute also streams these test logs in real time to drastically reduce time wasted in debugging failed tests.
+
+***
+
+#### 8. **Does HyperExecute provide APIs to consume logs?**
+
+ Yes, HyperExecute provides APIs to consume all the logs generated during test execution for offline usage.
+
+***
+
+#### 9. **Does HyperExecute provide the ability to store test artifacts?**
+
+ Yes, HyperExecute provides convenient artifact management where you can upload test artifacts or any files or folders generated during test execution. These artifacts are stored on HyperExecute. HyperExecute exposes APIs to access these as well.
+
+***
+
+#### 10. **Does HyperExecute record video recording of the test session?**
+
+ Yes, HyperExecute generates video recording of every single end to end test triggered over the platform. All the features available in the standard automation platform including video, screenshot, network logs and a lot more, are available in HyperExecute.
+
+***
+
+#### 11. **Can I run parallel tests using HyperExecute?**
+
+ Absolutely, HyperExecute’s core feature is to provide a massively parallel testing infrastructure where the platform intelligently distributes tests across multiple nodes.
+
+***
+
+#### 12. **What are the configurations for HyperExecute virtual machines?**
+
+ HyperExecute provides a generous configuration for virtual machines to run your tests. Windows comes with 7 GB of memory and 4 cores of processors, Linux comes with 4 GB of memory and 2 cores of processors, Mac comes with 7 GB of memory and 4 cores of processors. HyperExecute also provides the ability to customize the execution environment for enterprise accounts.
+
+***
+
+#### 13. **Can I group my tests to run in sequence instead of randomly distributing them?**
+
+ Yes, HyperExecute provides directives to group dependent tests together which need to run in sequence. Using dynamic test discovery, users can write unique test discovery commands for every node, where dependent tests will run in sequence. HyperExecute allows various directives to construct sophisticated testing pipelines to fulfill your use cases.
+
+***
+
+#### 14. **Can I run performance tests with HyperExecute?**
+
+ Though HyperExecute currently doesn’t have a deep support for performance testing, nothing stops the users from running performance tests. HyperExecute will still orchestrate and run performance tests in parallel and provide the terminal logs like all other tests.
+
+***
+
+#### 15. **In which regions does HyperExecute provide its testing infrastructure?**
+
+ HyperExecute is available in more than 40 cloud availability regions across the globe. HyperExecute is supported by multiple hyper clouds which makes it available in most of the availability zones across the globe.
+
+***
+
+#### 16. **How can I open my Microsoft Excel files with HyperExecute?**
+
+ You can access your Microsoft Excel files with HyperExecute by modifying the files that contain your tests. In order to automate the opening of your Excel file, set the `ms:waitForAppLaunch` and `appArguments` capabilities to:
+
+ ```bash
+ cap.setCapability("ms:waitForAppLaunch", 15);
+ cap.setCapability("appArguments", " /e ");
+ ```
+
+ This will ensure that your Excel file is opened after 15 seconds, and that it is opened in edit mode. If you want your file to open after a certain period of time, just enter that time in the `ms:waitForAppLaunch` field.
+
+***
+
+#### 17. **How can I access my Hub URL?**
+
+ Your Hub URL can be accessed from our [automation page](https://automation.lambdatest.com/build), along with your username and access key. Click on the **Access Key** button on the right side of your screen to retrieve your Hub URL. The image below indicates exactly where you can find your Hub URL.
+
+
+
+***
+
+>If you have more questions, then just give us a window.openLTChatWidget()}>shout and we will answer them for you.
diff --git a/docs/hyperexecute-generate-sample-yaml.mdx b/docs/hyperexecute-generate-sample-yaml.mdx
new file mode 100644
index 000000000..776caa5c0
--- /dev/null
+++ b/docs/hyperexecute-generate-sample-yaml.mdx
@@ -0,0 +1,56 @@
+---
+title: "Generate your HyperExecute YAML file"
+sidebarTitle: "Generate a Sample YAML"
+description: "This document helps you to understand how to generate the HyperExecute YAML files using the HyperExecute dashboard and then a sample yaml file for understanding the YAML"
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation']
+"og:description": "This document helps you to understand how to generate the HyperExecute YAML files using the HyperExecute dashboard and then a sample yaml file for understanding the YAML"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+You can also generate the HyperExecute YAML directly from the HyperExecute Portal. To accomplish this, follow the below mentioned steps:
+
+**Step 1:** Go to [HyperExecute dashboard](https://hyperexecute.lambdatest.com/hyperexecute), click on the **Help Center** and select **Generate YAML** from the dropdown.
+
+**Step 2:** Select your preferred test automation framework.
+
+**Step 3:** You will be redirected to the configuring section, where you can configure the HyperExecute YAML parameters. Click on **Generate YAML** button.
+
+**Step 4:** Once done, you can download the YAML file using the small icon on top. Alternatively, you can copy the contents of the file and modify them further according to your needs on your favorite IDE.
+
+
+
+
+HyperExecute supports multiple languages and testing frameworks. See the comprehensive list & samples [here](/support/docs/hyperexecute-supported-languages-and-frameworks/).
+
+
+## Sample HyperExecute YAML
+A sample HyperExecute YAML file looks like this:
+
+```yaml
+---
+version: 0.1
+runson: linux
+
+autosplit: true
+concurrency: 2
+
+pre:
+ - mvn dependency:resolve
+
+testDiscovery:
+ type: raw
+ mode: static
+ command: grep 'test name' xml/testng_linux.xml | awk '{print$2}' | sed 's/name=//g' | sed 's/>//g'
+
+testRunnerCommand: mvn test -Dplatname=linux -Dmaven.repo.local=./.m2 dependency:resolve -DselectedTests=$test
+
+retryOnFailure: true
+maxRetries: 1
+
+jobLabel: [selenium-testng, linux, v1, autosplit]
+```
diff --git a/docs/hyperexecute-github-app-integration.mdx b/docs/hyperexecute-github-app-integration.mdx
new file mode 100644
index 000000000..96f41ffb7
--- /dev/null
+++ b/docs/hyperexecute-github-app-integration.mdx
@@ -0,0 +1,140 @@
+---
+title: "GitHub App Integration Support for HyperExecute"
+sidebarTitle: "Set Up the GitHub App (Short-Lived Tokens)"
+description: " GitHub App Integration Support for HyperExecute"
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'GitHub App', 'Integrations', 'Products', 'Automated testing alerts', 'DevOps communication']
+"og:description": " GitHub App Integration Support for HyperExecute"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+
+This is currently in the **Beta** version.
+
+
+HyperExecute supports integration with GitHub App, enabling secure, fine-grained, and scalable access to your GitHub repositories without relying on long-lived Personal Access Tokens (PATs).
+
+With this integration, HyperExecute automatically generates short-lived installation access tokens via GitHub App for all Git-related operations in Projects and Workflows, enhancing security, compliance, and maintainability.
+
+This integration supports three onboarding paths:
+- **'s Marketplace GitHub App** (Public Cloud)
+- **Your Existing GitHub App** (On-Prem / Private Cloud)
+- **Private GitHub App Dedicated to Your Organization** (On-Prem / Air-Gapped)
+
+## How It Works
+1. Install a GitHub App using one of the three supported approaches.
+2. Complete the post-installation registration within the platform.
+3. HyperExecute backend (Logistics) sends data to Sentinel to persist details in the `github_app_integration` table.
+4. For customer-managed GitHub App, create an org-level secret using the Logistics Secrets API: `github_app_private_key_{{git_tenant}}`.
+
+Once setup is complete, all HyperExecute Project and Workflow Git operations use short-lived installation tokens instead of PAT tokens. The PAT-based flow is used only as a fallback when no GitHub App is configured.
+
+## Installation Approaches
+HyperExecute supports three installation models, depending on your cloud type and organizational setup.
+
+### Approach 1: 's Marketplace GitHub App (Public Cloud)
+
+**Prerequisites :**
+
+- Admin permissions in your target GitHub organization
+
+**Installation Steps**
+
+1. Navigate to [GitHub Marketplace](https://github.com/marketplace)
+2. Search for "" or "HyperExecute"
+3. Open the GitHub App listing
+4. Click **Install**
+5. Select your target GitHub Organization
+ - For GitHub Enterprise, installation must be completed per organization
+6. Configure repository access:
+ - **All repositories** (recommended)
+ - **Select repositories**
+7. Review the required permissions:
+ - **Contents** (read/write)
+ - **Metadata** (read)
+8. Click **Install** to complete the installation
+
+**Post-Installation Configuration**
+
+After installation, GitHub automatically redirects you to: `https://{{accounts_base_url}}/org-settings/hyperexecute/git-integration`
+
+The redirect URL includes an `installation_id` parameter required for configuration.
+
+
+**Note:** Only Org Admins can complete the registration. Organization users can view mappings but cannot modify them.
+
+
+### Approach 2: Your Existing GitHub App (On-Prem)
+
+**Prerequisites**
+
+- A GitHub App already exists in your GitHub organization
+- Admin access to the GitHub App
+- Required permissions are configured:
+ - **Contents** (read)
+ - **Metadata** (read)
+
+**Installation Steps**
+
+1. Obtain your app's installation ID from:
+ - Navigate to **GitHub App → Installations → Installation URL**
+ - Example URL format: `https://github.com/settings/installations/{installation_id}`
+
+2. Navigate to the setup page:
+```
+ https://{{accounts_base_url}}/org-settings/hyperexecute/git-integration
+```
+
+3. Manually enter:
+ - `installation_id`
+ - Additional app details as required
+
+
+**Note:** For GitHub Enterprise setups with multiple organizations, repeat this setup for each organization.
+
+
+**Additional Required Configuration**
+
+Create an org-level secret via the Logistics Secret API:
+```
+github_app_private_key_{{git_tenant}}
+```
+
+This private key is used to generate short-lived tokens internally.
+
+### Approach 3: Private GitHub App (On-Prem Dedicated App)
+
+**Prerequisites**
+
+- Admin access in your target GitHub organization
+- Private GitHub App installation URL shared by the /Workflow team
+- Setup URL inside the GitHub App updated to the private setup URL
+
+**Installation Steps**
+
+1. Navigate to the private app installation URL:
+```
+ https://github.com/apps/{private-app-name}/installations/new
+```
+
+2. Select your GitHub organization
+ - Enterprise customers must repeat this process for each organization
+
+3. Configure repository access permissions
+
+4. Review and confirm the installation
+
+**Post-Installation Configuration**
+
+GitHub will redirect you to the private setup URL configured for your environment:
+```
+https://{{private_accounts_base_url}}/org-settings/hyperexecute/git-integration
+```
+
+The redirect contains the `installation_id` parameter, which is required for configuration.
+
+
+**Note:** Only Org Admins can complete this configuration step.
+
diff --git a/docs/hyperexecute-gitignore.mdx b/docs/hyperexecute-gitignore.mdx
new file mode 100644
index 000000000..d18ea9e82
--- /dev/null
+++ b/docs/hyperexecute-gitignore.mdx
@@ -0,0 +1,46 @@
+---
+title: "Ignore Unnecessary Files in your Payload"
+sidebarTitle: "Exclude Files from the Payload"
+description: "Optimize HyperExecute CLI with .gitignore & .hyperexecuteignore files. Exclude unneeded files for efficient test script execution."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation']
+"og:description": "Optimize HyperExecute CLI with .gitignore & .hyperexecuteignore files. Exclude unneeded files for efficient test script execution."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+When you trigger your job, [HyperExecute CLI](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/) creates a zip of your test scripts before sending it for execution on the HyperExecute Platform.
+
+If you want to ignore any un-necessary files during this process, you can use the `.hyperexecuteignore` file. The HyperExecuteIgnore file serves as a configuration file to specify files that should be excluded when HyperExecute prepares a zipped archive of your test scripts. This functionality is similar to the `.gitignore` file used in Git version control.
+
+## Benefits
+Excluding unnecessary files from the archive offers several advantages:
+
+- **Improved Security and Privacy :** HyperExecuteIgnore allows you to exclude sensitive information like log files, hidden files, or any other private data from the test archive. This helps maintain security and protects confidential information during test execution.
+- **Reduced Archive Size :** By omitting irrelevant files, the zipped archive containing your test scripts becomes smaller. This is beneficial for storage and transmission purposes.
+- **Faster Testing Process :** A smaller archive size can potentially lead to a faster test execution process, as less
+data needs to be transferred and uploaded to the testing environment.
+
+## How to write `.hyperexecuteignore` file?
+
+The HyperExecuteIgnore file follows a format similar to the .gitignore file used with Git. It allows the use of wildcards to exclude patterns of files based on specific naming conventions.
+
+```bash
+examplename
+hyperexecute.exe
+*.type
+examplename/
+```
+The above file would make sure that following are excluded while the zip is created:
+
+1. **examplename**: All files and folder with the name `examplename`.
+2. **examplename.type**: All files with the name `examplename` and format `type`.
+3. ***.type**: All files of the format `type`.
+4. **examplename/**: All files and folders under the parent folder called `examplename`.
+
+
+- By leveraging `.hyperexecuteignore` file, you can achieve similar functionality to `.gitignore` and streamline the test execution process by keeping the archive size minimal.**
+
+- If both files are present in the directory then the files listed in the `.gitignore` only are ignored. The items listed in `.gitignore` file take **precedence** over the items listed under `.hyperexecuteignore`.
+
diff --git a/docs/hyperexecute-guided-walkthrough.mdx b/docs/hyperexecute-guided-walkthrough.mdx
new file mode 100644
index 000000000..11d3ef17f
--- /dev/null
+++ b/docs/hyperexecute-guided-walkthrough.mdx
@@ -0,0 +1,131 @@
+---
+title: "Guided Walkthrough of HyperExecute"
+sidebarTitle: "Explore the Job Dashboard"
+description: "Learn how to manage Jobs, configure tunnels, upgrade subscriptions, and access detailed test and job information. Discover the power of custom report, analytic."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'FAQs']
+"og:description": "Learn how to manage Jobs, configure tunnels, upgrade subscriptions, and access detailed test and job information. Discover the power of custom report, analytic."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+This page gives you a guided walkthrough of all the things on the HyperExecute Dashboard and how you can get the most out of the platform once you have successfully [run your first sample Job](/support/docs/hyperexecute-running-your-first-job/).
+
+## Jobs Page
+
+All the tests on HyperExecute get executed as a Job. All the Jobs can be found on our [Jobs page](https://hyperexecute.lambdatest.com/hyperexecute). Each [Job](/support/docs/hyperexecute-status/#1-job-level-status) has a [`Status`](/support/docs/hyperexecute-status/#3-stage-level-status), a unique `Job Number`, a set of [`Labels`](/support/docs/deep-dive-into-hyperexecute-yaml/#joblabel), info on number of [`Tasks`](/support/docs/hyperexecute-status/#2-task-level-status) executed as part of that Job, and a `Summary` section followed by the details of the `Job Duration` and who initiated the Job.
+
+On this page you have other things such as filters, help center, docs, [secrets management](/support/docs/hyperexecute-how-to-save-and-manage-secrets/) and much more. You can also filter through all of the jobs on the basis of the date, status, type etc.
+
+
+
+
+Learn more about [Secrets Management](/support/docs/hyperexecute-how-to-save-and-manage-secrets/), getting [User Name and Access Key](/support/docs/hyperexecute-how-to-get-my-username-and-access-key/) from our [Knowledge Base](/support/docs/hyperexecute-knowledge-base/)
+
+
+### Top Panel
+
+
+
+The top panel contains multiple items:
+
+- **Parallel**: It reflects the number of tasks running parallelly
+- **Queued**: It shows number of the tasks queued and are not yet started.
+- **Configure Tunnel**: Tunnel is used to ensure the security of your data for private websites.
+- **Announcements**: The latest announcements and updates can be found here.
+- **Settings**: Manage all of your account and organisation details in this section.
+- **Upgrade**: You can upgrade your subscription from here.
+
+***
+
+## Job Details Page
+
+You can click on a particular Job to navigate to the Job Details Page.
+
+- On the top you can see all the Job related details like Job Number, Summary etc.
+ - **Job Number** - The Number of your Job.
+ - **Summary** - A brief breakdown of all of your tests on the basis of their status.
+ - **Status** - The status of your Job.
+ - **Created At** - The date of the creation of the Job.
+ - **User** - Your user details who triggered the Job.
+ - **Job Duration**: The time it took to run your entire Job.
+ - **Test Duration**: The time it took to run your tests.
+ - **Type**: The job type (Selenium, Playwright, etc) along with the mode of the job (AutoSplit or Matrix).
+ - **[Artifacts](/support/docs/hyperexecute-artifacts/)**: Can be used to configure and generate custom reports and artifacts.
+ - **[Report](/support/docs/hyperexecute-reports/)**: A detailed report for your test execution for the Job.
+- The left side shows all the Tasks (Just-in-time testing environments) that were a part of the Job.
+- Each Task has 3 types of Stages : [Pre stages, Scenario stages, Post stages](/support/docs/hyperexecute-status/#3-stage-level-status).
+
+{/* > **Note** - You can learn about Job, Tasks and Stages [here](/support/docs/hyperexecute-concepts/). */}
+
+
+
+***
+
+## Test Details
+
+You can access a much more detailed section for your test cases on the Automation dashboard by clicking on the **Test** button.
+
+
+
+It provides you with all the necessary data points that you need for your test.
+
+### Basic Summary
+You can see the details of your test on the panel on the top of the screen. It contains several details like the browser, the test status, the test name, and more.
+
+- **Test Status**: The status of your test. If the test has passed, the status will be passed.
+- **Test Name**: The name of your test. You can rename the test, copy the name and see all the tests in the build.
+- **Test ID**: The test ID of your test. You can copy the test ID by clicking on the **Copy** button.
+- **Browser**: The browser on which your tests are run.
+- **OS**: The Operating System on which your tests are run.
+- **Resolution**: The resolution of the screen.
+- **Duration**: The amount of time it took for your test to run.
+- **Test Meta Data**: You can view the test meta data by clicking on the **info** icon.
+- **Tunnel Information**: Tells whether you have used a tunnel to run your tests or not.
+- **Share**: You can share the details of this test by clicking on the **Share** icon.
+- **Delete**: You can delete the test entirely by clicking on the **Delete** icon.
+### Videos and Screenshots
+
+HyperExecute provides you with tools like videos and screenshots of your tests to give you a clear picture of what goes on in the background.
+
+### Commands and Logs
+
+You can access the commands involved in the test, and the logs on the right hand side on this Dashboard.
+
+- **All Commands**: Each command that is run as a part of your test case is shown here. Each command also contains its own parameters, that can be accessed by hovering on the command and clicking on **View Parameters**.
+- **Network**: Access the network logs while your tests were getting executed on the **Network** tab.
+- **Logs**: View all kinds of logs at one place. You can toggle between the **Console Logs**, **Terminal Logs** and the **Test Framework Logs**.
+
+
+
+
+: You can download the logs by clicking on the Download button on the top right-hand corner of the logs tab.
+
+
+
+## Test Summary Hyperlink
+
+This introduces clickable links within your **test summary**. When you click on these hyperlinks, it dynamically redirects you to the automation dashboard, providing immediate access to detailed test information corresponding to the specific test status clicked.
+
+Additionally, upon redirection, the automation dashboard opens the relevant tab that aligns with the selected test status, streamlining your experience.
+
+
+
+### How to Activate Test Summary Hyperlinks
+
+- #### Update your Org Configuration :
+
+
+
+- #### Frontend Configuration :
+
+
+> For frontend activation, please contact us via our window.openLTChatWidget()}>**24×7 chat support** or you can also drop a mail to **support@testmuai.com**.
+
+
+- #### Backend Configuration :
+
+ Update your designated HyperExecute YAML file with [`buildConfig`](/support/docs/deep-dive-into-hyperexecute-yaml/#buildconfig) configuration to activate the "**Test Summary Hyperlink**" feature. This configuration allows you to define specific parameters that govern the behavior of the hyperlinks based on the test summary status.
diff --git a/docs/hyperexecute-how-smart-caching-boosts-tests-speed.mdx b/docs/hyperexecute-how-smart-caching-boosts-tests-speed.mdx
new file mode 100644
index 000000000..8607312ad
--- /dev/null
+++ b/docs/hyperexecute-how-smart-caching-boosts-tests-speed.mdx
@@ -0,0 +1,58 @@
+---
+title: "Turbo Boost Your Tests Execution with Smart Caching"
+sidebarTitle: "Speed Up Jobs with Smart Caching"
+description: "Learn how to turbo boost your tests execution using the smart caching concept in hyperexecute"
+keywords: ['Smart Caching', 'TestMu AI', 'TestMu AI HyperExecute documentation', 'How Smart Caching turbo boost your tests execution with HyperExecute']
+"og:description": "Learn how to turbo boost your tests execution using the smart caching concept in hyperexecute"
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+Smart Caching significantly reduces test execution times by optimizing resource utilization and minimizing redundant processes. This document provides a comprehensive technical overview of Smart Caching, detailing its architecture, functionalities, and benefits for software development teams.
+
+## Architecture
+
+Smart Caching operates on a distributed caching architecture, leveraging a network of caching nodes across 's global infrastructure. This ensures low latency and high availability for test execution, regardless of user location.
+
+The core functionalities of Smart Caching include:
+
+### Dependency Doping
+
+Caches frequently used libraries, frameworks, and test assets at caching nodes, eliminating the need for repeated downloads and reducing test execution times.
+
+### Environment Enhancers
+
+Pre-configures and stores ready-to-use testing environments based on test configurations, eliminating time-consuming environment setup for each test case.
+
+## Functionalities
+Key functionalities offered by Smart Caching:
+
+- **Global Caching Network:** Leverage a geographically distributed network of caching nodes for optimal performance and low latency.
+
+- **Intelligent Caching Strategy:** Smart algorithms identify and cache the most frequently used dependencies and environments for maximum efficiency.
+
+{/* - **Automatic Cache Invalidation:** Expired or outdated cached data is automatically invalidated and refreshed to ensure test accuracy. */}
+
+- **Seamless Scalability:** The caching network automatically scales to accommodate growing test suites and concurrent test runs.
+
+{/* - **Granular Control:** Configure caching behavior for specific dependencies, environments, and test cases based on your specific needs.
+
+- **Real-time Monitoring:** Monitor cache utilization and performance metrics within the HyperExecute interface. */}
+
+## Benefits
+
+Implementing Smart Caching offers numerous benefits:
+
+- **50%-80% Faster Test Execution:** Dramatically reduce test execution times, freeing up valuable developer resources.
+
+- **Improved Resource Utilization:** Minimize resource consumption, leading to cost savings and infrastructure optimization.
+
+- **Enhanced Developer Productivity:** Developers spend less time waiting for tests, focusing more on coding, innovation, and problem-solving.
+
+- **Increased Scalability:** Handle large and complex test suites with ease due to the inherent scalability of the caching network.
+
+## Additional Resources
+
+- [Deliver Faster: How Smart Caching Turbocharges Your Testing Workflow](https://www.lambdatest.com/blog/how-smart-caching-turbocharges-your-testing-workflow/)
diff --git a/docs/hyperexecute-how-to-configure-os-and-browser.mdx b/docs/hyperexecute-how-to-configure-os-and-browser.mdx
new file mode 100644
index 000000000..3adf5232d
--- /dev/null
+++ b/docs/hyperexecute-how-to-configure-os-and-browser.mdx
@@ -0,0 +1,71 @@
+---
+title: "How to configure Operating System and Browser in your Test Suite?"
+sidebarTitle: "Set OS & Browser"
+description: "Discover the correct way to configure the operating system and the browser capabilities in your codebase to execute in the HyperExecute platform."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation', 'How to Find the Correct Concurrency']
+"og:description": "Discover the correct way to configure the operating system and the browser capabilities in your codebase to execute in the HyperExecute platform."
+---
+
+import { HyperExecuteSupportedLanguageRepos } from '/snippets/HyperExecuteSupportedLanguageRepos.mdx';
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+This documentation will guide you through configuring the Operating System and Browser for your test suite on HyperExecute. We will cover the step-by-step method to implement the configuration for various test frameworks supported by HyperExecute. Each section provides practical examples to help you integrate HyperExecute with your existing automation suite.
+
+For demonstration purposes, we use the TestNG sample repository. However, you can apply the same concepts to your preferred framework. You can access the sample repositories for your required frameworks:
+
+
+
+## Step 1: Update Capabilities in your test suite
+Configuring the capabilities is the first step to define the environment for your tests. These capabilities allow you to specify parameters such as the Operating System, Browser, and Browser Version on which your tests will run. capabilities serve as a bridge between your test framework and the HyperExecute cloud infrastructure.
+
+### Key Attributes to Configure
+- **`platform` :** Specifies the operating system (e.g., Windows, macOS, or Linux).
+- **`browserName` :** Indicates the browser to be used (e.g., Chrome, Firefox, or Edge).
+- **`version` :** Defines the specific version or sets it as latest to always use the most recent version.
+
+Below is a Java example using the TestNG framework:
+```java title="Test.java"
+DesiredCapabilities caps = new DesiredCapabilities();
+caps.setCapability("platform", "Windows");
+caps.setCapability("browserName", "Chrome");
+caps.setCapability("version", "latest"); //latest, dev, beta, latest-1, latest-2, ...
+```
+
+The above configuration ensures that your tests run on Windows OS using the latest version of Google Chrome.
+
+## Step 2: Configure your HyperExecute YAML file
+The HyperExecute YAML configuration file is the blueprint for running your tests in the HyperExecute cloud environment. It defines the testing environment, execution strategy, and resource allocation. Properly configuring this file ensures that your tests are executed efficiently across the desired platforms and browsers.
+
+
+
+ [AutoSplit mode](/support/docs/deep-dive-into-hyperexecute-yaml/#autosplit) automatically splits your scenarios among the concurrent number of tasks and executes them parallelly. This ensures optimal utilization of resources and significantly reduces the overall execution time of your test suite.
+
+ In this method, you simply set the [`runson`](/support/docs/deep-dive-into-hyperexecute-yaml/#runson) flag to specify the Operating System for running your tests.
+
+ ```yaml title="hyperexecute_autosplit.yaml"
+ runson: linux #linux, win, win11, mac, mac13
+ ```
+
+> 📕 Learn more about [AutoSplit Test Method](/support/docs/hyperexecute-auto-split-strategy/)
+
+
+
+
+ [Matrix mode](/support/docs/deep-dive-into-hyperexecute-yaml/#matrix) allows you to run the same set of tests across multiple combinations of environments, configurations, or parameters. This is particularly useful for ensuring that your software works correctly under different conditions, such as various operating systems, browser versions, or dependency files.
+
+ - **`runson: ${matrix.os}` :** Dynamically selects the operating system from the matrix.os list (Windows, macOS, Linux) for each test job.
+ - **`os` :** Lists the operating systems for testing: `win`, `win11`, `mac`, `mac13`, and `linux`.
+
+ ```yaml title="hyperexecute_matrix.yaml"
+ runson: ${matrix.os}
+
+ matrix:
+ os: ["win", "mac", "linux"] #linux, win, win11, mac, mac13
+ ```
+
+> 📕 Learn more about [Matrix Test Method](/support/docs/hyperexecute-matrix-multiplexing-strategy)
+
+
+
diff --git a/docs/hyperexecute-how-to-configure-sourcePayload.mdx b/docs/hyperexecute-how-to-configure-sourcePayload.mdx
new file mode 100644
index 000000000..808100323
--- /dev/null
+++ b/docs/hyperexecute-how-to-configure-sourcePayload.mdx
@@ -0,0 +1,197 @@
+---
+title: "How to configure sourcePayload"
+sidebarTitle: "Source Tests from Git"
+description: "Learn to configure sourcePayload in HyperExecute with ease, allowing secure and direct sourcing of test scripts from your Git provider for seamless testing integration."
+keywords: ['TestMu AI Hyperexecute', 'TestMu AI Hyperexecute help', 'TestMu AI Hyperexecute documentation']
+"og:description": "Learn to configure sourcePayload in HyperExecute with ease, allowing secure and direct sourcing of test scripts from your Git provider for seamless testing integration."
+---
+
+import { BrandName } from "/snippets/BrandName.mdx";
+
+---
+
+When you run your tests on HyperExecute, the test scripts are zipped, encrypted and uploaded to our secure servers temporarily for execution through the [HyperExecute CLI binary](/support/docs/hyperexecute-cli-run-tests-on-hyperexecute-grid/). However, to make this process seamlessly fit in your pipeline you can use the `sourcePayload` Yaml parameter.
+
+Once you set `sourcePayload`, your test scripts are directly sourced from your Git provider with the help of secure access tokens and only your HyperExecute YAML file is encrypted and sent through the HyperExecute CLI. Learn more detailed documentation below.
+
+***
+
+## Setting up
+
+You can start by configuring the `sourcePayload` key in the [HyperExecute YAML](/support/docs/deep-dive-into-hyperexecute-yaml/) file. The format is explained below.
+
+```bash
+sourcePayload:
+ platform: git
+ link: https://--------
+ ref:
+ accessToken:
+ commit:
+```
+
+1. **platform**: The platform on which your repository exists. It should be set to `git` if your repository is deployed on GitHub or GitLab.
+
+2. **link**: The link to your repository that contains the code to be tested.
+
+3. **ref**: The name of the branch that you want to test.
+
+4. **accessToken**: Your personal access token (PAT), generated on your Git platform. If you want to know how to generate a PAT for GitHub, go through [this](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) section.
+
+
+: You don’t need to use a Personal Access Token if your repository is public.
+
+
+
+5. **commit**: If you want to run a specific commit file other than the **HEAD** commit, then you need to define here the specific commit ID.
+
+
+As a best practice, you should not use your PAT directly in the YAML file. Instead of that, you can make use of our [vault](/support/docs/hyperexecute-how-to-save-and-manage-secrets/) feature and add the PAT to your secrets. To use the vault feature in the HyperExecute YAML file, you can refer the example given below.
+
+
+```yaml title="hyperexecute.yaml"
+sourcePayload:
+ platform: git
+ link: https://--------
+ ref:
+ accessToken: ${{ .secrets. }}
+ commit:
+```
+
+You can assign a name to your PAT via the HyperExecute vault feature and replace it in place of the `GIT_PAT` tag in the example given above.
+
+
+***
+
+### Sample YAML file
+
+A sample HyperExecute YAML file is added below for your reference.
+
+```yaml title="hyperexecute.yaml"
+---
+version: "0.1"
+globalTimeout: 90
+testSuiteTimeout: 90
+testSuiteStep: 90
+runson: win
+autosplit: true
+retryOnFailure: false
+testType: "playwright"
+maxRetries: 1
+concurrency: 1
+pre:
+ - npm install
+ - npx playwright install
+cacheKey: '{{ checksum "package-lock.json" }}'
+cacheDirectories:
+ - node_modules
+testDiscovery:
+ type: raw
+ mode: dynamic
+ command: grep -lr 'describe' ltblogsearch.test.js
+testRunnerCommand: npm test -- $test
+sourcePayload:
+ platform: git
+ link:
+ ref:
+ accessToken:
+```
+
+### Generating a Personal Access Token
+
+
+Generate Personal Access Token on GitHub
+ You can generate a **PAT** on **GitHub** by following the steps below.
+
+***
+
+1. Log in to your [GitHub](https://github.com/ "https://github.com/") account. You will be redirected to your homepage on GitHub.
+
+
+2. Click on your profile on the top right-hand side corner of your page to access your **Settings**.
+
+
+3. Go to the bottom of the **Settings** page and click on **Developer settings**.
+
+
+4. Click on **Tokens (classic)** to generate your own Personal Access Token.
+
+
+5. Click on **Generate new token** and select the **classic** or **fine-grained** version as per your choice.
+
+
+6. Proceed to configuring the PAT and click on **Generate token** to create your Personal Access Token.
+
+
+