BrowserTest Class

new BrowserTest(config: BrowserTestConfig)

interface BrowserTestConfig {
  /** API key for authentication */
  apiKey: string;
  /** Base URL for API calls (default: https://api.browsertest.in) */
  baseUrl?: string;
  /** Request timeout in milliseconds (default: 30000) */
  timeout?: number;
  /** Number of retries for failed requests (default: 3) */
  retries?: number;
}

import { BrowserTest } from 'browsertest-sdk';

const bt = new BrowserTest({
  apiKey: process.env.BROWSERTEST_API_KEY,
  baseUrl: 'https://api.browsertest.in', // Optional
  timeout: 30000, // Optional
  retries: 3 // Optional
});

testConnection(): Promise<boolean>

const isConnected = await bt.testConnection();
console.log('API Connection:', isConnected ? 'OK' : 'Failed');

getUsage(): Promise<QuotaInfo>

interface QuotaInfo {
  plan: string;
  usage: {
    screenshot: {
      used: number;
      limit: number;
      remaining: number;
    };
    agentic: {
      used: number;
      limit: number;
      remaining: number;
    };
    total: {
      screenshot: number;
      agentic: number;
    };
  };
}

const usage = await bt.getUsage();
console.log('Current plan:', usage.plan);
console.log('Screenshots remaining:', usage.usage.screenshot.remaining);
console.log('Agentic tests remaining:', usage.usage.agentic.remaining);

try {
  await bt.screenshot.take({ url: 'https://example.com' });
} catch (error) {
  if (error.name === 'BrowserTestAuthError') {
    console.log('Authentication failed - check your API key');
  }
}

try {
  await bt.testing.execute({ instructions: 'test', url: 'https://example.com' });
} catch (error) {
  if (error.name === 'BrowserTestQuotaError') {
    console.log('Quota exceeded:', error.quotaInfo);
  }
}

try {
  await bt.screenshot.take({ url: 'https://example.com' });
} catch (error) {
  if (error.name === 'BrowserTestAPIError') {
    console.log('API error:', error.status, error.message);
  }
}

try {
  await bt.testing.execute({
    instructions: 'complex test',
    url: 'https://example.com'
  });
} catch (error) {
  if (error.name === 'BrowserTestTimeoutError') {
    console.log('Request timed out - try simplifying your test');
  }
}

const bt = new BrowserTest({
  apiKey: 'your-api-key-here'
});

const bt = new BrowserTest({
  apiKey: process.env.BROWSERTEST_API_KEY,
  baseUrl: 'https://api.browsertest.in',
  timeout: 60000, // 1 minute for complex operations
  retries: 5 // More retries for unreliable networks
});

const config = {
  development: {
    apiKey: process.env.BROWSERTEST_DEV_KEY,
    timeout: 30000,
    retries: 1
  },
  staging: {
    apiKey: process.env.BROWSERTEST_STAGING_KEY,
    timeout: 45000,
    retries: 3
  },
  production: {
    apiKey: process.env.BROWSERTEST_PROD_KEY,
    timeout: 60000,
    retries: 5
  }
};

const environment = process.env.NODE_ENV || 'development';
const bt = new BrowserTest(config[environment]);

// ❌ Bad - hardcoded API key
const bt = new BrowserTest({
  apiKey: 'sk-1234567890abcdef'
});

// ✅ Good - environment variable
const bt = new BrowserTest({
  apiKey: process.env.BROWSERTEST_API_KEY
});

// ✅ Better - validation
if (!process.env.BROWSERTEST_API_KEY) {
  throw new Error('BROWSERTEST_API_KEY environment variable is required');
}

const bt = new BrowserTest({
  apiKey: process.env.BROWSERTEST_API_KEY
});

class BrowserTestWrapper {
  constructor(config) {
    this.bt = new BrowserTest(config);
  }

  async safeOperation(operation, ...args) {
    try {
      return await operation.apply(this.bt, args);
    } catch (error) {
      console.error('BrowserTest operation failed:', error.message);

      // Handle specific error types
      switch (error.name) {
        case 'BrowserTestAuthError':
          throw new Error('Invalid API key - please check your configuration');
        case 'BrowserTestQuotaError':
          throw new Error(`API quota exceeded. Used: ${error.quotaInfo?.usage?.total || 'unknown'}`);
        case 'BrowserTestTimeoutError':
          throw new Error('Operation timed out - try again or simplify your request');
        default:
          throw error;
      }
    }
  }
}

async function initializeBrowserTest() {
  const bt = new BrowserTest({
    apiKey: process.env.BROWSERTEST_API_KEY
  });

  // Test connection before proceeding
  const isConnected = await bt.testConnection();
  if (!isConnected) {
    throw new Error('Failed to connect to BrowserTest API');
  }

  // Check usage
  const usage = await bt.getUsage();
  console.log(`Connected to BrowserTest (${usage.plan} plan)`);
  console.log(`Usage: ${usage.usage.screenshot.used}/${usage.usage.screenshot.limit} screenshots`);

  return bt;
}

class BrowserTestManager {
  constructor() {
    this.instances = new Map();
  }

  getInstance(configKey) {
    if (!this.instances.has(configKey)) {
      const config = this.getConfig(configKey);
      this.instances.set(configKey, new BrowserTest(config));
    }
    return this.instances.get(configKey);
  }

  getConfig(configKey) {
    // Load configuration based on key
    const configs = {
      default: {
        apiKey: process.env.BROWSERTEST_API_KEY,
        timeout: 30000
      },
      extended: {
        apiKey: process.env.BROWSERTEST_API_KEY,
        timeout: 60000,
        retries: 5
      }
    };
    return configs[configKey] || configs.default;
  }

  async cleanup() {
    // Close any persistent connections if needed
    this.instances.clear();
  }
}

// Usage
const manager = new BrowserTestManager();
const bt = manager.getInstance('extended');

// Use bt...

// Cleanup when done
process.on('SIGINT', async () => {
  await manager.cleanup();
  process.exit(0);
});