[cdpfleet](https://cdpfleet.com/) / [Browsers](https://cdpfleet.com/browsers) / Google Chrome

Chromium family · Official Google build

# Google Chrome, *one socket* away.

The real Google Chrome, with stable, beta and dev channels and recent previous majors. The best choice when a site must see genuine Chrome.

[Open in the code builder](https://cdpfleet.com/docs/builder?browser=chrome)[Reference](https://cdpfleet.com/docs/browsers/chrome)

-   **/chrome/session**launch endpoint
-   **1.60**Playwright client
-   **1**thread headless

## Why Google Chrome

-   Sites that must see **genuine Google Chrome** — its own build, user agent and client hints.
-   Testing the next release with the **beta and dev channels**, or reproducing an old bug on a **pinned previous major**.
-   Puppeteer and other CDP tools with `"cdp": true`, and [persistent profiles](https://cdpfleet.com/profiles).

## Versions on the fleet now

**stable**157.0.8103.78**beta**159.0.8154.6**dev**159.0.8144.0**pinned**156.0.8078.79**pinned**155.0.8059.84

Choose a build with `channel`; without one you get stable.

Pin a previous major with `{"version": "…"}` — the reference page lists the ones available now.

New majors are announced on [/docs/updates](https://cdpfleet.com/docs/updates).

## Launch it

One HTTPS call to `POST /chrome/session` returns a WebSocket URL; connect to it with Playwright's `chromium.connect()` (client 1.60), or launch with `"cdp": true` and use `cdpUrl`. A headless session takes 1 thread, a headful one 2.

Google Chrome: launch, open a page, print its title

 

```node
// npm install playwright@1.60.0
// Browsers run on cdpfleet, so no `npx playwright install` is needed.
import { chromium } from 'playwright';

const KEY = process.env.CDPFLEET_API_KEY;

// 1. Launch the browser
const res = await fetch('https://starter.cdpfleet.com/chrome/session', {
  method: 'POST',
  headers: { 'x-api-key': KEY, 'content-type': 'application/json' },
  body: JSON.stringify({
    proxy: 'http://user:pass@proxy.example.com:8080',
    headless: 'new',
  }),
});
if (!res.ok) throw new Error(`launch failed: ${res.status} ${await res.text()}`);
const { wsUrl } = await res.json();

// 2. Connect and drive it
const browser = await chromium.connect(wsUrl, { headers: { 'x-api-key': KEY } });
const page = await browser.newPage();
await page.goto('https://example.com');
console.log(await page.title());
await browser.close(); // ends the session and stops billing
```

```python
# pip install playwright==1.60.0 requests
# Browsers run on cdpfleet, so no `playwright install` is needed.
import os
import requests
from playwright.sync_api import sync_playwright

KEY = os.environ["CDPFLEET_API_KEY"]

# 1. Launch the browser
res = requests.post(
    "https://starter.cdpfleet.com/chrome/session",
    headers={"x-api-key": KEY},
    json={
        "proxy": "http://user:pass@proxy.example.com:8080",
        "headless": "new",
    },
    timeout=60,
)
res.raise_for_status()
ws_url = res.json()["wsUrl"]

# 2. Connect and drive it
with sync_playwright() as p:
    browser = p.chromium.connect(ws_url, headers={"x-api-key": KEY})
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()  # ends the session and stops billing
```

```java
// Maven: com.microsoft.playwright:playwright:1.60.0  and  com.google.code.gson:gson:2.11.0
// Run with PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1: browsers run on cdpfleet.
import com.google.gson.JsonParser;
import com.microsoft.playwright.*;
import java.net.URI;
import java.net.http.*;
import java.util.Map;

public class Example {
  public static void main(String[] args) throws Exception {
    String key = System.getenv("CDPFLEET_API_KEY");

    // 1. Launch the browser
    String body = """
        {
          "proxy": "http://user:pass@proxy.example.com:8080",
          "headless": "new"
        }
        """;
    HttpResponse<String> res = HttpClient.newHttpClient().send(
        HttpRequest.newBuilder(URI.create("https://starter.cdpfleet.com/chrome/session"))
            .header("x-api-key", key)
            .header("content-type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build(),
        HttpResponse.BodyHandlers.ofString());
    if (res.statusCode() != 200) {
      throw new RuntimeException("launch failed: " + res.statusCode() + " " + res.body());
    }
    String wsUrl = JsonParser.parseString(res.body()).getAsJsonObject().get("wsUrl").getAsString();

    // 2. Connect and drive it
    try (Playwright playwright = Playwright.create()) {
      Browser browser = playwright.chromium().connect(wsUrl,
          new BrowserType.ConnectOptions().setHeaders(Map.of("x-api-key", key)));
      Page page = browser.newPage();
      page.navigate("https://example.com");
      System.out.println(page.title());
      browser.close(); // ends the session and stops billing
    }
  }
}
```

```csharp
// dotnet add package Microsoft.Playwright --version 1.60.0
// Browsers run on cdpfleet, so no `playwright install` is needed.
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using Microsoft.Playwright;

var key = Environment.GetEnvironmentVariable("CDPFLEET_API_KEY")!;

// 1. Launch the browser
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("x-api-key", key);
var body = """
    {
      "proxy": "http://user:pass@proxy.example.com:8080",
      "headless": "new"
    }
    """;
var res = await http.PostAsync("https://starter.cdpfleet.com/chrome/session",
    new StringContent(body, Encoding.UTF8, "application/json"));
if (!res.IsSuccessStatusCode)
    throw new Exception($"launch failed: {(int)res.StatusCode} {await res.Content.ReadAsStringAsync()}");
var wsUrl = (await res.Content.ReadFromJsonAsync<JsonElement>()).GetProperty("wsUrl").GetString()!;

// 2. Connect and drive it
using var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.ConnectAsync(wsUrl, new BrowserTypeConnectOptions
{
    Headers = new Dictionary<string, string> { ["x-api-key"] = key },
});
var page = await browser.NewPageAsync();
await page.GotoAsync("https://example.com");
Console.WriteLine(await page.TitleAsync());
await browser.CloseAsync(); // ends the session and stops billing
```

```go
// go get github.com/playwright-community/playwright-go@v0.6000.0
//
// One-time driver setup (needs Node.js 18+): playwright-go can no longer download the
// 1.60.0 driver itself, so build it from npm and point PLAYWRIGHT_DRIVER_PATH at it:
//   mkdir -p ~/.cache/pw-driver-1.60.0 && cd ~/.cache/pw-driver-1.60.0 &&
//     curl -sL https://registry.npmjs.org/playwright-core/-/playwright-core-1.60.0.tgz | tar xz &&
//     ln -sf "$(command -v node)" node
//   export PLAYWRIGHT_DRIVER_PATH=~/.cache/pw-driver-1.60.0
// Browsers run on cdpfleet, so no browsers are downloaded (SkipInstallBrowsers).
package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strings"

	"github.com/playwright-community/playwright-go"
)

func main() {
	key := os.Getenv("CDPFLEET_API_KEY")

	// 1. Launch the browser
	body := `{
	  "proxy": "http://user:pass@proxy.example.com:8080",
	  "headless": "new"
	}`
	req, _ := http.NewRequest("POST", "https://starter.cdpfleet.com/chrome/session", strings.NewReader(body))
	req.Header.Set("x-api-key", key)
	req.Header.Set("content-type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		msg, _ := io.ReadAll(res.Body)
		log.Fatalf("launch failed: %s %s", res.Status, msg)
	}
	var session struct {
		WsURL string `json:"wsUrl"`
	}
	if err := json.NewDecoder(res.Body).Decode(&session); err != nil {
		log.Fatal(err)
	}

	// 2. Connect and drive it (Install fetches only the Playwright driver, once)
	opts := &playwright.RunOptions{SkipInstallBrowsers: true}
	if err := playwright.Install(opts); err != nil {
		log.Fatal(err)
	}
	pw, err := playwright.Run(opts)
	if err != nil {
		log.Fatal(err)
	}
	defer pw.Stop()
	browser, err := pw.Chromium.Connect(session.WsURL, playwright.BrowserTypeConnectOptions{
		Headers: map[string]string{"x-api-key": key},
	})
	if err != nil {
		log.Fatal(err)
	}
	page, err := browser.NewPage()
	if err != nil {
		log.Fatal(err)
	}
	if _, err := page.Goto("https://example.com"); err != nil {
		log.Fatal(err)
	}
	title, _ := page.Title()
	fmt.Println(title)
	browser.Close() // ends the session and stops billing
}
```

[This program on GitHub →](https://github.com/cdpfleet/cdpfleet/tree/main/examples/browsers/chrome)

## Launch options

| Option | What it does |
| --- | --- |
| [`proxy_rules`](https://cdpfleet.com/docs/browsers/chrome#opt-proxy_rules) | Send specific destination hosts through specific proxies. |
| [`inactivity_timeout`](https://cdpfleet.com/docs/browsers/chrome#opt-inactivity_timeout) | End the session after this long with no traffic on its WebSocket. |
| [`overall_timeout`](https://cdpfleet.com/docs/browsers/chrome#opt-overall_timeout) | Hard cap on the session's total lifetime, regardless of activity. |
| [`memory`](https://cdpfleet.com/docs/browsers/chrome#opt-memory) | Give the session 2, 3 or 4 times your plan's memory; it counts as that many times the threads. |
| [`downloads`](https://cdpfleet.com/docs/browsers/chrome#opt-downloads) | Keep every file the browser downloads, to fetch after the session. |
| [`vpn_tunnel`](https://cdpfleet.com/docs/browsers/chrome#opt-vpn_tunnel) | VPN Tunnel: UDP/WebRTC full support — all of the browser's traffic, UDP included, goes through the residential exit. |
| [`vpn`](https://cdpfleet.com/docs/browsers/chrome#opt-vpn) | Own network (dedicated plans): send all of the browser's traffic through your own VPN instead of a proxy. |
| [`headless`](https://cdpfleet.com/docs/browsers/chrome#opt-headless) | Run without a display. |
| [`channel`](https://cdpfleet.com/docs/browsers/chrome#opt-channel) | Release channel of the browser build. |
| [`version`](https://cdpfleet.com/docs/browsers/chrome#opt-version) | Pin an older major version. |
| [`cdp`](https://cdpfleet.com/docs/browsers/chrome#opt-cdp) | Also expose a Chrome DevTools Protocol endpoint (cdpUrl). |
| [`screencast`](https://cdpfleet.com/docs/browsers/chrome#opt-screencast) | Stream the page to your code (Playwright page.screencast). |
| [`live_view`](https://cdpfleet.com/docs/browsers/chrome#opt-live_view) | Make a headless session watchable and controllable from outside. |
| [`screen_size`](https://cdpfleet.com/docs/browsers/chrome#opt-screen_size) | Resolution of the session's own display (headful only). |
| [`keep_alive`](https://cdpfleet.com/docs/browsers/chrome#opt-keep_alive) | Keep the session when your client disconnects (dedicated threads only). |
| [`start_url`](https://cdpfleet.com/docs/browsers/chrome#opt-start_url) | Open this page at launch so the session can be driven in live view with no client connected. |
| [`profile`](https://cdpfleet.com/docs/browsers/chrome#opt-profile) | Restore a saved browser profile and save it again when the session ends. |
| [`record`](https://cdpfleet.com/docs/browsers/chrome#opt-record) | Opt this session out of recording with false. |

Every session also needs a `proxy` — yours, or the [residential proxy](https://cdpfleet.com/residential-proxy).

## Related

Cases, recipes, posts and comparisons about this — updated as new ones are published.

### Reference docs

The details, options and errors.

-   [Google Chrome reference](https://cdpfleet.com/docs/browsers/chrome)Versions and every launch option.
-   [Quickstart](https://cdpfleet.com/docs/quickstart)Your first session in five minutes.
-   [CDP & Puppeteer](https://cdpfleet.com/docs/cdp)Connecting over `cdpUrl`.

### Cases 29

Real problems solved end to end, run on production in five languages.

-   [Case 89: Watch a page live: its XHR calls, DOM changes and WebSocket messages over SSE and a signed webhook](https://cdpfleet.com/docs/cases/watch-a-page-live)Keep a Chrome of yours on a page that updates itself (the ISS position, polled about once a second), and get every matching XHR response and every change to one…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/89-watch-a-page-live)
-   [Case 84: Does the TLS fingerprint (JA4) explain which browsers got in? Twelve browsers against six vendors](https://cdpfleet.com/docs/cases/ja4-vs-vendor-verdicts)Each of the twelve browsers from the real-site lab week loads a TLS echo page once, so we know the JA4, peetprint and HTTP/2 fingerprint it sends. Grouped by…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/84-ja4-vs-vendor-verdicts)
-   [Case 83: Brave's fingerprint randomisation per site, per context and per launch, and what public fingerprint pages make of it](https://cdpfleet.com/docs/cases/brave-farbling)Brave adds noise to canvas, audio, cores, memory and the plugin list, keyed to the site and the session. One probe on two made-up sites, the same site again, a…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/83-brave-farbling)
-   [Case 81: Behaviour scoring: Camoufox humanize on and off vs plain Chrome clicks on a public bot-test form](https://cdpfleet.com/docs/cases/behaviour-scoring-humanize)A public behavioural bot-test page scores how a demo login form was filled in: clicks, keystrokes, timing. Camoufox with `humanize` off, on and slowed down, and…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/81-behaviour-scoring-humanize)
-   [Case 77: Kasada and AWS WAF on real sites: twelve browsers, four sites, one exit each](https://cdpfleet.com/docs/cases/kasada-and-aws-waf-by-browser)Two real sites behind Kasada and two behind AWS WAF, loaded once by each of twelve browsers and by a returning Camoufox profile, through one sticky residential exit…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/77-kasada-and-aws-waf-by-browser)
-   [Case 75: HUMAN on real sites: twelve browsers, three sites, one exit each](https://cdpfleet.com/docs/cases/human-real-sites-by-browser)Three real sites behind HUMAN (formerly PerimeterX), chosen from our sweep as easy, medium and hard, loaded once by each of twelve browsers and by a returning…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/75-human-real-sites-by-browser)
-   [Case 73: Akamai on real sites: twelve browsers, three sites, one exit each](https://cdpfleet.com/docs/cases/akamai-real-sites-by-browser)Three real sites behind Akamai Bot Manager, chosen from our sweep as easy, medium and hard, loaded once by each of twelve browsers and by a returning Camoufox…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/73-akamai-real-sites-by-browser)
-   [Case 74: Does the browser agree with its IP? Timezone, language and WebRTC through exits in three countries](https://cdpfleet.com/docs/cases/timezone-locale-ip-consistency)Five setups through residential exits in the US, Germany and Japan: which ones keep timezone, language, Accept-Language, Intl formats and the WebRTC address…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/74-timezone-locale-ip-consistency)

[All cases →](https://cdpfleet.com/docs/cases) 29 match this topic

### Recipes 8

Complete programs for one setup each.

-   [Google Chrome, beta channel](https://cdpfleet.com/docs/examples#chrome-beta)Run the next Chrome release before it ships. Use `"dev"` for the dev channel.[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/chrome-beta)
-   [Pin an older Chrome major (156)](https://cdpfleet.com/docs/examples#pinned-version)Run a previous major to reproduce or compare behaviour. Previous majors rotate as new versions ship, so check the [Chrome page](https://cdpfleet.com/docs/browsers/chrome) for the…
-   [Chrome over CDP (connectOverCDP or Puppeteer)](https://cdpfleet.com/docs/examples#chrome-cdp)Launch with `"cdp": true` and connect to `cdpUrl` with Playwright's `connectOverCDP` — no client version matching — or with Puppeteer. See [CDP & Puppeteer](https://cdpfleet.com/docs/cdp).[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/chrome-cdp)
-   [Chrome you can disconnect from and come back to](https://cdpfleet.com/docs/examples#chrome-keep-alive)`keep_alive: true` (dedicated threads) keeps the browser when your code disconnects: reconnect to the same `wsUrl` within `inactivity_timeout` and your contexts,…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/chrome-keep-alive)
-   [Headless Chrome a person can watch and take over](https://cdpfleet.com/docs/examples#chrome-headless-live-view)Headful sessions are always watchable; a headless one needs `live_view: true` at launch. Then `POST /admin/session/live` on the session's router returns a screencast…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/chrome-headless-live-view)
-   [Chrome that stays logged in between sessions](https://cdpfleet.com/docs/examples#chrome-profile)`profile: "shop-login"` restores the profile's cookies, localStorage and IndexedDB at launch and saves them when the session ends — log in once and reuse it on every…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/chrome-profile)
-   [Headful Chrome that isn't recorded](https://cdpfleet.com/docs/examples#chrome-record-off)Headful sessions are [recorded](https://cdpfleet.com/docs/recordings) by default within your plan's limits; `"record": false` opts one launch out — for pages with personal or sensitive…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/chrome-record-off)
-   [Headful Chrome on a full-HD screen](https://cdpfleet.com/docs/examples#chrome-screen-size)`screen_size` sets the virtual display of a headful session (1920×1080 here). Pages only see it with a context created with `viewport: null` (Python…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/chrome-screen-size)

### Updates 2

Product news and browser releases.

-   [Chrome 157: HTTPS-First turned on (and off on cdpfleet), Protected Audience gone, same TLS fingerprint](https://cdpfleet.com/docs/updates/chrome-157)Stable Chrome on the fleet is now 157.0.8103.38: HTTPS-First mode (kept off on cdpfleet), Protected Audience gone, TLS and HTTP/2 unchanged.
-   [Chrome 156: CSS random(), IndexedDB on SQLite, same TLS fingerprint](https://cdpfleet.com/docs/updates/chrome-156)Stable Chrome on the fleet is now 156.0.8078.47: CSS random() and scroll-snap pair arrive, IndexedDB moves to SQLite, TLS and HTTP/2 fingerprints unchanged.

### Browser comparisons 9

Measured side by side on the fleet.

-   [Naver Whale vs Chrome](https://cdpfleet.com/docs/compare/whale-vs-chrome)Whale 5.41 runs on Chromium 156, one major behind Chrome 157, names itself in the user agent and client hints, and now sends the same TLS hello as Chrome. What that…
-   [Yandex Browser vs Chrome](https://cdpfleet.com/docs/compare/yandex-vs-chrome)Yandex Browser 26.8 runs on Chromium 150, six majors behind Chrome 156, names itself in the user agent and client hints, puts Russian first in navigator.languages…
-   [Chrome 155 vs Chrome 154](https://cdpfleet.com/docs/compare/chrome-155-vs-154)Chrome 155 on the fleet: four web features a page can detect, the same TLS and HTTP/2 fingerprint as 154, and release-note features sessions don't get.
-   [Opera vs Chrome](https://cdpfleet.com/docs/compare/opera-vs-chrome)Opera 137 runs on Chromium 153, two majors behind Chrome 155, and names itself everywhere — OPR in the user agent, Opera in the client hints — while its TLS, HTTP/2…
-   [Chrome vs Brave](https://cdpfleet.com/docs/compare/chrome-vs-brave)The same Chromium 155 underneath, two very different faces: Brave calls itself Chrome in the user agent but Brave in the client hints, randomises cores, screen and…
-   [Chrome vs Chromium](https://cdpfleet.com/docs/compare/chrome-vs-chromium)Google's Chrome against the Chromium build Playwright ships: seven majors apart, one brand missing from the client hints, one TLS extension fewer — and, contrary to…
-   [Chrome vs Edge](https://cdpfleet.com/docs/compare/chrome-vs-edge)Two real Chromium browsers on the fleet, measured side by side: identical engine, identical HTTP/2 and header order, and exactly three things a site can tell apart —…
-   [Chrome 156 (beta) vs Chrome 154](https://cdpfleet.com/docs/compare/chrome-156-beta-vs-154)Two majors ahead of stable, measured on the fleet: what 155 and 156 add and remove, which of it a page can already detect in the beta, what is identical on the wire,…

[All browser comparisons →](https://cdpfleet.com/docs/compare) 9 match this topic

## Read next

[Browsers →](https://cdpfleet.com/browsers)[Microsoft Edge →](https://cdpfleet.com/browsers/edge)[Brave →](https://cdpfleet.com/browsers/brave)[Opera →](https://cdpfleet.com/browsers/opera)

---
Source: https://cdpfleet.com/browsers/chrome · Markdown: https://cdpfleet.com/browsers/chrome.md · All docs for AI tools: https://cdpfleet.com/llms.txt