Testing Tools

LambdaTest Guide: Browser & App Testing in the Cloud

HelpMeTest

HelpMeTest

— 5 min read
LambdaTest Guide: Browser & App Testing in the Cloud

LambdaTest has grown into one of the most feature-rich cloud testing platforms, offering cross-browser testing, real device testing, and their own HyperExecute test orchestration engine. This guide covers everything from initial setup through advanced parallel execution and CI/CD integration.

What Is LambdaTest?

LambdaTest is a cloud-based testing platform with:

  • Browser automation — 3,000+ browser/OS combinations via Selenium and Playwright
  • Real device cloud — physical iOS and Android devices for mobile testing
  • HyperExecute — their distributed test execution engine that claims up to 70% faster test runs
  • Smart UI testing — visual regression across browsers
  • LT Browser — local browser for responsive testing
  • Accessibility testing — WCAG compliance checks

Plans start at $15/month for individuals; team plans begin around $99/month.

Setting Up LambdaTest

1. Create an Account

Register at lambdatest.com. The freemium tier gives 100 automation minutes per month — enough to evaluate the platform.

2. Get Credentials

From your profile, navigate to Account Settings → Password & Security to find your:

  • Username (your email)
  • Access Token
export LT_USERNAME=<span class="hljs-string">"your-email@example.com"
<span class="hljs-built_in">export LT_ACCESS_KEY=<span class="hljs-string">"your-access-token"

3. Capability Configuration

LambdaTest uses W3C WebDriver capabilities. Use their Capabilities Generator to build the right configuration for your target environment.

Selenium Automation

Node.js + WebDriverIO

npm install --save-dev @wdio/cli webdriverio

wdio.lambdatest.conf.js:

exports.config = {
  user: process.env.LT_USERNAME,
  key: process.env.LT_ACCESS_KEY,
  
  hostname: 'hub.lambdatest.com',
  port: 443,
  protocol: 'https',
  path: '/wd/hub',
  
  capabilities: [{
    browserName: 'Chrome',
    browserVersion: 'latest',
    'LT:Options': {
      platform: 'Windows 11',
      build: 'My Build',
      name: 'Homepage Test',
      network: true,
      video: true,
      console: true,
    }
  }],
  
  specs: ['./tests/**/*.spec.js'],
  framework: 'mocha',
  reporters: ['spec'],
};

Python + Selenium

from selenium import webdriver
import os

lt_options = {
    'user': os.environ['LT_USERNAME'],
    'accessKey': os.environ['LT_ACCESS_KEY'],
    'build': 'Python Build',
    'name': 'Login Test',
    'platform': 'Windows 11',
    'browserName': 'Chrome',
    'version': 'latest',
    'network': True,
    'video': True,
    'console': True,
    'visual': True,
}

options = webdriver.ChromeOptions()
options.set_capability('LT:Options', lt_options)

driver = webdriver.Remote(
    command_executor='https://hub.lambdatest.com/wd/hub',
    options=options
)

driver.get('https://example.com')
print(driver.title)
driver.quit()

Java + TestNG

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.testng.annotations.*;
import java.net.URL;
import java.util.HashMap;

public class LambdaTest {
    WebDriver driver;

    @BeforeMethod
    public void setup() throws Exception {
        ChromeOptions options = new ChromeOptions();
        
        HashMap<String, Object> ltOptions = new HashMap<>();
        ltOptions.put("username", System.getenv("LT_USERNAME"));
        ltOptions.put("accessKey", System.getenv("LT_ACCESS_KEY"));
        ltOptions.put("build", "Java Build");
        ltOptions.put("name", "Sample Test");
        ltOptions.put("platform", "Windows 11");
        ltOptions.put("browserVersion", "latest");
        
        options.setCapability("LT:Options", ltOptions);
        
        driver = new RemoteWebDriver(
            new URL("https://hub.lambdatest.com/wd/hub"),
            options
        );
    }

    @Test
    public void testHomepage() {
        driver.get("https://example.com");
        assert driver.getTitle().contains("Example");
    }

    @AfterMethod
    public void teardown() {
        if (driver != null) driver.quit();
    }
}

HyperExecute: Fast Parallel Testing

HyperExecute is LambdaTest's test orchestration layer that distributes tests across multiple machines automatically. Instead of waiting for sequential test runs, it splits your suite across concurrent executors.

Install HyperExecute CLI

# macOS
curl -O https://downloads.lambdatest.com/hyperexecute/darwin/hyperexecute
<span class="hljs-built_in">chmod +x hyperexecute

<span class="hljs-comment"># Linux
curl -O https://downloads.lambdatest.com/hyperexecute/linux/hyperexecute
<span class="hljs-built_in">chmod +x hyperexecute

<span class="hljs-comment"># Windows
curl -O https://downloads.lambdatest.com/hyperexecute/windows/hyperexecute.exe

HyperExecute YAML Configuration

Create hyperexecute.yaml:

version: 0.1
globalTimeout: 90
testSuiteTimeout: 90
testSuiteStep: 90

runson: win
autosplit: true
retryOnFailure: true
maxRetries: 1

concurrency: 5

env:
  TARGET_OS: Windows 11

pre:
  - npm install

testDiscovery:
  type: raw
  mode: dynamic
  command: grep -r --include="*.spec.js" -l "describe"

testRunnerCommand: npx wdio run wdio.lambdatest.conf.js --spec $test

Run with HyperExecute

./hyperexecute \
  --user $LT_USERNAME \
  --key <span class="hljs-variable">$LT_ACCESS_KEY \
  --config hyperexecute.yaml

HyperExecute automatically discovers your tests, splits them across concurrent executors, and shows a unified report. On large suites, this can cut run time from 30 minutes to under 10.

Playwright on LambdaTest

LambdaTest supports Playwright natively via their @lambdatest/playwright-driver package:

npm install @lambdatest/playwright-driver
const { chromium } = require('@lambdatest/playwright-driver');

(async () => {
  const capabilities = {
    browserName: 'Chrome',
    browserVersion: 'latest',
    'LT:Options': {
      platform: 'Windows 11',
      build: 'Playwright Build',
      name: 'PW Test',
      user: process.env.LT_USERNAME,
      accessKey: process.env.LT_ACCESS_KEY,
    }
  };

  const browser = await chromium.connect({
    wsEndpoint: `wss://cdp.lambdatest.com/playwright?capabilities=${encodeURIComponent(JSON.stringify(capabilities))}`
  });

  const page = await browser.newPage();
  await page.goto('https://example.com');
  console.log(await page.title());
  await browser.close();
})();

Real Device Testing

For mobile apps, LambdaTest provides physical iOS and Android devices:

  1. Navigate to Real Devices in the dashboard
  2. Upload your .apk or .ipa file
  3. Select device + OS version
  4. Run manual or automated Appium tests

Appium configuration for real device:

options = {
    'deviceName': 'iPhone 15',
    'platformVersion': '17',
    'platformName': 'iOS',
    'app': 'lt://APP_URL',  # from dashboard after upload
    'isRealMobile': True,
    'LT:Options': {
        'user': os.environ['LT_USERNAME'],
        'accessKey': os.environ['LT_ACCESS_KEY'],
        'build': 'iOS Build',
        'name': 'App Test',
    }
}

Tunnel for Local Testing

LambdaTest Tunnel lets cloud browsers reach your local server:

# Download
curl -O https://downloads.lambdatest.com/tunnel/v3/linux/64bit/LT_Linux.zip
unzip LT_Linux.zip

<span class="hljs-comment"># Start tunnel
./LT --user <span class="hljs-variable">$LT_USERNAME --key <span class="hljs-variable">$LT_ACCESS_KEY --tunnelName my-tunnel

Enable tunnel in capabilities:

'LT:Options': {
  tunnel: true,
  tunnelName: 'my-tunnel',
}

CI/CD Integration

GitHub Actions

name: LambdaTest Cross-Browser

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - run: npm ci
      
      - name: Run tests on LambdaTest
        env:
          LT_USERNAME: ${{ secrets.LT_USERNAME }}
          LT_ACCESS_KEY: ${{ secrets.LT_ACCESS_KEY }}
        run: npx wdio run wdio.lambdatest.conf.js

GitLab CI

cross-browser-tests:
  image: node:20
  script:
    - npm ci
    - npx wdio run wdio.lambdatest.conf.js
  variables:
    LT_USERNAME: $LT_USERNAME
    LT_ACCESS_KEY: $LT_ACCESS_KEY

LambdaTest vs BrowserStack vs Sauce Labs

Feature LambdaTest BrowserStack Sauce Labs
Starting price $15/mo $29/mo $199/mo
HyperExecute / Smart runner Yes Automate Pro Virtual USB
Real devices Yes Yes Yes
Playwright native Yes Yes Limited
Free tier 100 min/mo 100 min/mo 150 min/mo

LambdaTest's HyperExecute differentiates it for teams with large test suites where execution speed matters. BrowserStack has a larger device catalog. Sauce Labs has the longest track record but higher pricing.

Adding Continuous Monitoring

Cloud testing platforms excel at pre-deployment validation — but what monitors production after you deploy?

HelpMeTest runs your critical user flows continuously against production, 24/7, alerting you within minutes when tests fail. Write tests in plain English, get alerts via email or Slack, and see session replays for every failure. Free plan includes 10 tests and unlimited health checks.

LambdaTest for release validation + HelpMeTest for production monitoring is a complete testing stack for teams that care about uptime.

Summary

LambdaTest gives you:

  • 3,000+ browser/OS combinations via Selenium, Playwright, and Cypress
  • HyperExecute for dramatically faster parallel execution
  • Real device cloud for iOS and Android app testing
  • Tunnel for local/staging environment testing
  • Competitive pricing starting at $15/month

The setup is straightforward: credentials in environment variables, capabilities pointing at hub.lambdatest.com, and your existing test code works with minimal changes.

Read more