[cdpfleet](https://cdpfleet.com/) / Community plan

Free plan

# Real browsers in the cloud, *free*.

The Community plan gives you 2 threads with 60 browser-minutes each per day, every browser on the fleet and a proxy included — for trying cdpfleet and for small projects. No trial expiry, no charges.

[Sign up free](https://cdpfleet.com/app#sign-up)[Community vs paid](https://cdpfleet.com/upgrade)

-   **2**threads
-   **60**min per thread per day
-   **15**min per session
-   **$0**forever

## What you get

Community is a shared plan with the same fleet as the paid ones: Google Chrome with its channels, Edge, Brave, Opera, Firefox, Camoufox, WebKit and the stealth builds — 12 desktop browsers, driven with Playwright from Node.js, Python, Java, C# or Go, or over CDP.

A headless browser takes 1 thread and a headful one 2, so you can run two headless sessions or one headful session at a time. Minutes are counted per thread: a headful session uses both threads' minutes — up to 60 minutes of headful a day, the same as two headless sessions of 60 minutes. The allowance resets at midnight UTC.

### Community — free

Free forever, for trying cdpfleet and small projects: every browser on the fleet, with proxies included. No trial expiry and no charges — you verify a card once, one account per card. [Sign up free](https://cdpfleet.com/app#sign-up) and activate it in the dashboard.

Threads

2 (a headful browser takes both)

Browser-minutes

60 per thread per day

Session length

Up to 15 minutes

Proxies

Included, shared — slower at peak

Priority

Lowest; capacity shared by all Community users

Not included

Recordings, persistent profiles, keep-alive

The residential proxy can be added as on any plan. Request data from Community sessions may be used to learn which browser setups work on which sites, so don't sign in to accounts on it ([Terms, section 4A](https://cdpfleet.com/terms)).

## A proxy is included

Every cdpfleet session goes through a proxy. On Community the plan brings its own: leave `proxy` out of the launch and the session uses the **Community proxy**, or send a `cdpfleet-plan` token to choose an exit country and keep the same IP for a while — the dashboard's Proxies page builds the token for you.

The Community proxy is shared by everyone on the plan, so pages load slower at peak times. Your own proxies work too, and the [residential proxy](https://cdpfleet.com/residential-proxy) can be added from a prepaid balance exactly as on a paid plan.

A Community session through the included proxy, exiting in the US

 

```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/chromium/session', {
  method: 'POST',
  headers: { 'x-api-key': KEY, 'content-type': 'application/json' },
  body: JSON.stringify({
    proxy: 'cdpfleet-plan-country-us',
    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/chromium/session",
    headers={"x-api-key": KEY},
    json={
        "proxy": "cdpfleet-plan-country-us",
        "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": "cdpfleet-plan-country-us",
          "headless": "new"
        }
        """;
    HttpResponse<String> res = HttpClient.newHttpClient().send(
        HttpRequest.newBuilder(URI.create("https://starter.cdpfleet.com/chromium/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": "cdpfleet-plan-country-us",
      "headless": "new"
    }
    """;
var res = await http.PostAsync("https://starter.cdpfleet.com/chromium/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": "cdpfleet-plan-country-us",
	  "headless": "new"
	}`
	req, _ := http.NewRequest("POST", "https://starter.cdpfleet.com/chromium/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
}
```

## Limits, and what isn't included

-   **Sessions last up to 15 minutes.** Within a session the idle timeout is 120 seconds by default; set up to 5 minutes with `inactivity_timeout`.
-   **Lowest priority.** All Community users share one capacity cap; when it is full a launch gets `503 community_capacity_full` and should retry after `Retry-After`. When paid plans need room, Community sessions give way first — their leases renew every 5 minutes instead of 15.
-   **Up to 25% of the day's minutes in any rolling hour**, like every shared plan.
-   **Not included:** [session recordings](https://cdpfleet.com/recordings), [persistent profiles](https://cdpfleet.com/profiles) (a `profile` launch gets `403 profiles_disabled`) and `keep_alive`.

## How to get it

1.  [Sign up free](https://cdpfleet.com/app#sign-up) with your email.
2.  Sign in to the dashboard and choose **Verify a card and activate**. Stripe checks the card — it is never charged — and one card holds one Community account.
3.  Create an API key, pick a browser in the code generator, and run the program it writes — or press **Launch interactive** to [try the browser live](https://cdpfleet.com/launch-interactive) first.

Outgrow it any time: [see what a paid plan adds](https://cdpfleet.com/upgrade) — it is one click in the dashboard. A paid plan can also move back to Community at the end of its billing period.

## Your data on Community

Request data from Community sessions may be used to learn which browser setups work on which sites. Don't sign in to accounts or handle personal data on it; the details are in the [Terms, section 4A](https://cdpfleet.com/terms). Paid plans add privacy, priority, more threads, recordings and profiles.

## Related

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

### Reference docs

The details, options and errors.

-   [Plans & pricing → Community](https://cdpfleet.com/docs/pricing#community)The plan in the reference docs.
-   [Proxies](https://cdpfleet.com/docs/proxies)Proxy formats, rules and the residential proxy.
-   [Errors & limits](https://cdpfleet.com/docs/errors)`community_capacity_full`, `profiles_disabled` and the rest.
-   [Terms of Service](https://cdpfleet.com/terms)Section 4A covers the Community plan.

### 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 47: A first free scrape on the Community plan: no proxy to bring, country and sticky exits included](https://cdpfleet.com/docs/cases/community-first-scrape)On the free Community plan a launch without a proxy goes out through the plan's own shared proxy. Scrape a catalogue page, then pick a country and keep the same exit…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/cases/47-community-first-scrape)

### Recipes 1

Complete programs for one setup each.

-   [Community plan: the included proxy, US and sticky](https://cdpfleet.com/docs/examples#community-quickstart)On the free [Community plan](https://cdpfleet.com/docs/pricing#community) the proxy is included: leave `proxy` out, or send a `cdpfleet-plan` token like this one for a US exit that…[Code on GitHub](https://github.com/cdpfleet/cdpfleet/tree/main/examples/recipes/community-quickstart)

### Updates 2

Product news and browser releases.

-   [Sign-ups are open: start free on Community, upgrade from $7.50 a month](https://cdpfleet.com/docs/updates/signups-open)Anyone can now create a cdpfleet account — no waitlist, no invite. Start on the free Community plan (a card check, never charged), and move to a paid plan from $7.50…
-   [The free Community plan: what's in it and how to get an invite](https://cdpfleet.com/docs/updates/community-plan)Two threads with 60 browser-minutes each per day, every browser on the fleet and a proxy included — free, with no trial expiry. Invite-only while we open up.

### 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

[Shared threads →](https://cdpfleet.com/shared-threads)[Pricing →](https://cdpfleet.com/pricing)[Launch interactive →](https://cdpfleet.com/launch-interactive)[Residential proxy →](https://cdpfleet.com/residential-proxy)

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