[cdpfleet](https://cdpfleet.com/) / Dedicated threads

Plans · dedicated threads

# Browsers that are *yours*, around the clock.

A dedicated thread is capacity reserved for you: no daily minutes, no rolling hour, no leases. $8.50 per thread per month — $0.012 per browser-hour when it runs 24/7.

[Get started](https://cdpfleet.com/app)[See all prices](https://cdpfleet.com/pricing)

-   **$8.50**per thread / month
-   **∞**browser-minutes
-   **24 h**per session
-   **5–10,000**threads

## Reserved, not pooled

With dedicated threads your thread count is the only limit: run that many browsers for as long as you like. Nothing counts down during the day, nothing caps the hour, and a launch is never refused because the shared fleet is busy.

One browser running around the clock is 720 browser-hours a month for $8.50 — $0.012 an hour. That is the lowest per-hour price on the [comparison with other cloud browsers](https://cdpfleet.com/pricing#compare).

| Dedicated threads | 5 | 10 | 25 | 50 | 100 | 500 | 1,000 | 2,500 | 5,000 | 10,000 | More than 10,000 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Dedicated$8.50 / thread / month | **$42.50** | **$85** | **$212.50** | **$425** | **$850** | **$4,250** | **$8,500** | **$21,250** | **$42,500** | **$85,000** | **Custom**[Contact sales](#contact) |

## Long sessions and keep\_alive

-   **Sessions up to 24 hours.** Set `overall_timeout` for a hard cap.
-   **Idle timeout up to 24 hours.** The default is 120 s; set `inactivity_timeout` (e.g. `"10m"`) to keep a quiet browser open while your code thinks or waits.
-   **`keep_alive`:** a disconnect no longer ends the session. Reconnect to the same `wsUrl` within the idle timeout and your contexts, pages and logins are still there — for long agent runs, deploys of your own code, or flaky networks.
-   **Launch interactive** sessions can wait for you as long as the idle timeout allows — see [Launch interactive](https://cdpfleet.com/launch-interactive).

Chrome you can disconnect from and come back to (dedicated threads)

 

```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',
    keep_alive: true,
    inactivity_timeout: '10m',
  }),
});
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 context = browser.contexts()[0]; // the default context — it survives a reconnect
const page = context.pages()[0] ?? await context.newPage();
await page.goto('https://example.com');
console.log(await page.title());
await browser.close(); // with keep_alive this only disconnects: end the session with DELETE /v1/me/threads/{sessionId}, or it ends after inactivity_timeout
```

```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",
        "keep_alive": True,
        "inactivity_timeout": "10m",
    },
    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})
    context = browser.contexts[0]  # the default context — it survives a reconnect
    page = context.pages[0] if context.pages else context.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()  # with keep_alive this only disconnects: end the session with DELETE /v1/me/threads/{sessionId}, or it ends after inactivity_timeout
```

```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",
          "keep_alive": true,
          "inactivity_timeout": "10m"
        }
        """;
    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)));
      BrowserContext context = browser.contexts().get(0); // the default context — it survives a reconnect
      Page page = context.pages().isEmpty() ? context.newPage() : context.pages().get(0);
      page.navigate("https://example.com");
      System.out.println(page.title());
      browser.close(); // with keep_alive this only disconnects: end the session with DELETE /v1/me/threads/{sessionId}, or it ends after inactivity_timeout
    }
  }
}
```

```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",
      "keep_alive": true,
      "inactivity_timeout": "10m"
    }
    """;
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 context = browser.Contexts[0]; // the default context — it survives a reconnect
var page = context.Pages.Count > 0 ? context.Pages[0] : await context.NewPageAsync();
await page.GotoAsync("https://example.com");
Console.WriteLine(await page.TitleAsync());
await browser.CloseAsync(); // with keep_alive this only disconnects: end the session with DELETE /v1/me/threads/{sessionId}, or it ends after inactivity_timeout
```

```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",
	  "keep_alive": true,
	  "inactivity_timeout": "10m"
	}`
	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)
	}
	context := browser.Contexts()[0] // the default context — it survives a reconnect
	var page playwright.Page
	if pages := context.Pages(); len(pages) > 0 {
		page = pages[0]
	} else if page, err = context.NewPage(); 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() // with keep_alive this only disconnects: end the session with DELETE /v1/me/threads/{sessionId}, or it ends after inactivity_timeout
}
```

## What it's for

### Always-on workloads

Monitoring, long crawls and queues that keep browsers busy most of the day.

### Agents that wait

An agent that waits on a model or a person keeps its browser open with a long idle timeout and `keep_alive`.

### Logins kept warm

Sign in once and keep the session for hours — or save it as a [persistent profile](https://cdpfleet.com/profiles) for the next launch.

### Predictable cost

A flat monthly price per browser slot, metered to the second for your own reports.

## Dedicated or shared?

If your browsers run a few hours a day, [shared threads](https://cdpfleet.com/shared-threads) cost less: Shared 60 is $1.50, Shared 120 is $2, Shared 240 is $2.50, Shared 480 is $4 per thread per month. Need more than 10,000 threads? [Contact sales](#contact).

|  | Community | Shared | Dedicated |
| --- | --- | --- | --- |
| Price | Free | $1.50–$4 per thread / month | $8.50 per thread / month |
| Concurrent browsers | 2 threads | Up to your thread count | Up to your thread count |
| Daily browser-minutes | 60 per thread | Each thread adds its minutes to one account pool | Unlimited |
| Rolling-hour limit | 25% of the daily pool in any 60 minutes | 25% of the daily pool in any 60 minutes | None |
| Session length | Up to 15 minutes | Up to 24 h | Up to 24 h |
| Session leases | Lowest priority, 5-minute leases | 15-minute leases, renewed automatically while shared capacity allows | None — capacity is reserved |
| Idle timeout | 120 s by default, up to 5 min | 120 s by default, up to 10 min | 120 s by default, up to 24 h |
| Launch rate | At least 2 per second and 10 per minute | Threads ÷ 5 per second, threads × 6 per minute (at least 2 and 10) | Twice the shared rate: threads ÷ 5 × 2 per second, threads × 12 per minute |
| Proxies | Included (shared), or your own | Your own, the residential add-on, or the free Community proxy | Your own, the residential add-on, or the free Community proxy |
| Per session | 50 open pages, 2 GB memory | 50 open pages, 4 GB memory | 50 open pages, 6 GB memory |
| Recordings, profiles, keep-alive, kept downloads | Not included | Recordings, kept downloads, and profiles: 20 per thread (at least 100) | Recordings, kept downloads, keep-alive, and profiles: 30 per thread (at least 100) |
| Sizes | One size, one per card | 5–1,000 threads | 5–10,000 threads, custom above |

## Related

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

### Reference docs

The details, options and errors.

-   [Plans & pricing](https://cdpfleet.com/docs/pricing)Sizes and prices.
-   [keep\_alive](https://cdpfleet.com/docs/browsers/chrome#opt-keep_alive)Reconnecting to the same browser.
-   [Sessions & billing](https://cdpfleet.com/docs/sessions)Timeouts and metering.

### Cases 2

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

-   [Case 80: How many tabs fit in one session, by plan, browser and "memory"](https://cdpfleet.com/docs/cases/tabs-and-memory-by-plan)A long Wikipedia article opened in one new tab after another until the session ends: on Community (2 GB), a shared plan (4 GB) and a dedicated thread (6 GB), in…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/80-tabs-and-memory-by-plan)
-   [Case 78: keep\_alive: an agent run that survives its client going away](https://cdpfleet.com/docs/cases/keep-alive-reconnect)An agent works through a catalogue in a headless Chrome session with `keep_alive`, then its client disconnects. A new client reconnects to the same session and…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/78-keep-alive-reconnect)

### Recipes 3

Complete programs for one setup each.

-   [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)
-   [Microsoft Edge over CDP that survives a disconnect](https://cdpfleet.com/docs/examples#edge-keep-alive)`keep_alive: true` (dedicated threads) with `"cdp": true`: disconnect from `cdpUrl`, reconnect within `inactivity_timeout` and your pages are where you left them.…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/edge-keep-alive)
-   [Headful Opera over CDP that survives a disconnect](https://cdpfleet.com/docs/examples#opera-keep-alive)`keep_alive: true` (dedicated threads) with `"cdp": true` on headful Opera: disconnect, reconnect to the same `cdpUrl` within `inactivity_timeout`, and the default…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/opera-keep-alive)

### Compared with other services 18

Prices, limits and features.

-   [cdpfleet vs Browserbase](https://cdpfleet.com/docs/compare/cdpfleet-vs-browserbase)Twelve real browsers over Playwright or CDP with your own proxies, or Chromium over CDP with built-in proxies, Stagehand and captcha solving. Prices, limits and…
-   [cdpfleet vs Browserless](https://cdpfleet.com/docs/compare/cdpfleet-vs-browserless)The longest-running headless-browser service against a browser fleet: 30-second "units" with 2–60-minute session caps and proxies by the megabyte, or threads metered…
-   [cdpfleet vs Steel](https://cdpfleet.com/docs/compare/cdpfleet-vs-steel)The open-source browser API for agents against a browser fleet: per-minute Chromium with proxies, captcha solves and a 15-minute-to-24-hour session cap by plan, or…
-   [cdpfleet vs Browser Use Cloud](https://cdpfleet.com/docs/compare/cdpfleet-vs-browser-use)The cheapest per-hour cloud browser for AI agents against a fleet of real browsers: one stealth Chromium over CDP at $0.02/hour plus traffic fees, or twelve browsers…
-   [cdpfleet vs Hyperbrowser](https://cdpfleet.com/docs/compare/cdpfleet-vs-hyperbrowser)A credits-based cloud Chrome with stealth, captcha solving and AI agents against a fleet of twelve real browsers: $0.10/hour plus $10/GB for its proxies (your own…
-   [cdpfleet vs Cloudflare Browser Run (Browser Rendering)](https://cdpfleet.com/docs/compare/cdpfleet-vs-cloudflare-browser-run)Cloudflare's serverless headless Chromium — formerly Browser Rendering — against a fleet of twelve real browsers: $0.09/hour beyond 10 free hours plus concurrency…
-   [cdpfleet vs Anchor Browser](https://cdpfleet.com/docs/compare/cdpfleet-vs-anchor-browser)An agent-focused cloud Chromium with captcha solving, managed logins and US hosting against a fleet of twelve real browsers: per-browser and per-hour fees plus…
-   [cdpfleet vs Kernel](https://cdpfleet.com/docs/compare/cdpfleet-vs-kernel)A sandboxed cloud Chromium for agents, billed per second with free standby, against a fleet of twelve real browsers on flat threads: $0.06/hour headless but…

[All compared with other services →](https://cdpfleet.com/docs/compare) 18 match this topic

## Read next

[Threads →](https://cdpfleet.com/threads)[Shared threads →](https://cdpfleet.com/shared-threads)[Live view →](https://cdpfleet.com/live-view)[Profiles →](https://cdpfleet.com/profiles)

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