Skip to main content
BrowserType provides methods to launch or connect to browser instances. Available through playwright.chromium, playwright.firefox, or playwright.webkit.

​
Inheritance

Extends: ChannelOwner

​
Methods

​
executablePath

Returns the path to the browser executable. 
executablePath(): string
Returns: string - Path to the browser executable Throws: Error if the browser is not supported on the current platform

​
name

Returns the browser name. 
name(): string
Returns: string - Browser name (‘chromium’, ‘firefox’, or ‘webkit’)

​
launch

Launches a new browser instance. 
launch(options?: LaunchOptions): Promise<Browser>
​
options
LaunchOptions
Launch configuration options
  • headless (boolean): Whether to run in headless mode (default: true)
  • executablePath (string): Path to browser executable
  • args (string[]): Additional arguments to pass to the browser
  • ignoreDefaultArgs (boolean | string[]): Ignore default arguments
  • channel (string): Browser channel to use
  • env (object): Environment variables
  • slowMo (number): Slows down operations by specified milliseconds
  • timeout (number): Maximum time in milliseconds to wait for browser to start
  • logger (Logger): Logger instance
Returns: Promise<Browser> - Browser instance

​
launchPersistentContext

Launches browser with persistent storage. 
launchPersistentContext(userDataDir: string, options?: LaunchPersistentContextOptions): Promise<BrowserContext>
​
userDataDir
string
required
Path to user data directory for persistent storage
​
options
LaunchPersistentContextOptions
Launch options combined with context options
Returns: Promise<BrowserContext> - Browser context with persistent storage

​
connect

Connects to a running browser instance. 
connect(options: ConnectOptions): Promise<Browser>
​
options
ConnectOptions
required
Connection options
  • wsEndpoint (string): WebSocket endpoint to connect to
  • timeout (number): Maximum time to wait for connection
  • slowMo (number): Slows down operations by specified milliseconds
  • headers (object): Additional HTTP headers
  • logger (Logger): Logger instance
Returns: Promise<Browser> - Connected browser instance

​
connectOverCDP

Connects to a browser over Chrome DevTools Protocol. 
connectOverCDP(endpointURL: string, options?: ConnectOverCDPOptions): Promise<Browser>
​
endpointURL
string
required
CDP endpoint URL (ws:// or http://)
​
options
ConnectOverCDPOptions
CDP connection options
  • timeout (number): Connection timeout
  • slowMo (number): Slow down operations
  • headers (object): Additional headers
  • logger (Logger): Logger instance
Returns: Promise<Browser> - Connected browser Note: Only supported for Chromium browsers

​
launchServer

Launches a browser server. 
launchServer(options?: LaunchServerOptions): Promise<BrowserServer>
​
options
LaunchServerOptions
Server launch options
Returns: Promise<BrowserServer> - Browser server instance

​
Usage Examples

​
Launch Browser

import { chromium } from 'playwright';

const browser = await chromium.launch({
  headless: false,
  slowMo: 100,
});

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

​
Connect to Remote Browser

import { chromium } from 'playwright';

const browser = await chromium.connect({
  wsEndpoint: 'ws://localhost:3000',
});

const page = await browser.newPage();
await page.goto('https://example.com');

​
Launch with Persistent Context

import { chromium } from 'playwright';

const context = await chromium.launchPersistentContext('./user-data', {
  headless: false,
  viewport: { width: 1280, height: 720 },
});

const page = await context.newPage();
await page.goto('https://example.com');

​
Connect Over CDP

import { chromium } from 'playwright';

const browser = await chromium.connectOverCDP('http://localhost:9222', {
  timeout: 30000,
});

const contexts = browser.contexts();
const page = contexts[0].pages()[0];

Build docs developers (and LLMs) love

Get started for freeTalk to us