Browser SDKs & Languages

Five SDKs drive the Cloud Browser. They split into two shapes: TypeScript and Python connect the browser for you and hand back a live Playwright object, while Go, Rust, and C++ cover the control plane: sessions, profiles, replays, and managed proxy. They hand you a CDP endpoint to drive with your language’s own automation library.

All bindings are published

@solarisdk/browser (npm), solari-browser (PyPI), and the Go, Rust, and C++ bindings in the solari-sdk GitHub org are all published — the install commands below resolve as shown.

Looking for VMs or sandboxes instead? Those have their own bindings. See SDKs & Languages. The two products ship separate packages, and both happen to export a class named Solari, so keep the install lines straight.

Availability

Language	Package / module	Surface
TypeScript	`@solarisdk/browser`	Full: control plane + `launch()` → Playwright
Python	`solari-browser`	Full: control plane + `launch()` → Playwright
Go	`github.com/solari-sdk/solari-browser-go`	Control plane + `Connect()` via chromedp
Rust	`solari-browser`	Control plane + `connect()` via chromiumoxide
C++ (17)	`solari::browser` (CMake)	Control plane + raw-CDP escape hatch

Why only two languages have `launch()`

launch() returns a connected browser over the Playwright wire protocol. Playwright has official clients for Node and Python only. There is no Playwright client for Go, Rust, or C++. Those three therefore create the session, hand back cdpEndpoint, and let you attach with a native CDP library. Everything else (stealth, proxy, profiles, recording) is gateway-side and identical in every language.

Driving the browser over raw CDP bypasses the pool’s Playwright-path input humanization. If you rely on stealth for interaction-heavy work, prefer the TypeScript or Python SDK.

TypeScript

npm install @solarisdk/browser

import { Solari } from "@solarisdk/browser";

const solari = new Solari({ apiKey: process.env.SOLARI_API_KEY! });

const browser = await solari.launch({ stealth: true, proxy: "us" });
const page = await browser.newPage();
await page.goto("https://example.com");
console.log(await page.title());

await browser.close();   // closes the browser AND releases the session
await solari.close();

Python

pip install solari-browser

Async, and a faithful port of the TypeScript surface, including launch(). You do not need patchright install chromium: the browser runs on our pool, only the driver is local.

import asyncio, os
from solari_browser import Solari

async def main():
    async with Solari(api_key=os.environ["SOLARI_API_KEY"]) as solari:
        async with await solari.launch(stealth=True, proxy="us") as browser:
            page = await browser.new_page()
            await page.goto("https://example.com")
            print(await page.title())

asyncio.run(main())

Go

go get github.com/solari-sdk/solari-browser-go

Context-first with typed errors. Connect attaches chromedp to the session’s CDP endpoint.

package main

import (
    "context"
    "log"
    "os"

    "github.com/chromedp/chromedp"
    solari "github.com/solari-sdk/solari-browser-go"
)

func main() {
    client, err := solari.NewClient(solari.ClientOptions{APIKey: os.Getenv("SOLARI_API_KEY")})
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()
    session, err := client.Sessions.Create(ctx, solari.CreateSessionOptions{
        Stealth: true,
        Proxy:   solari.ProxyCountry("us"),
    })
    if err != nil {
        log.Fatal(err)
    }
    defer client.Sessions.Release(ctx, session.ID)

    browserCtx, cancel, err := client.Connect(ctx, session)
    if err != nil {
        log.Fatal(err)
    }
    defer cancel()

    var title string
    if err := chromedp.Run(browserCtx,
        chromedp.Navigate("https://example.com"),
        chromedp.Title(&title),
    ); err != nil {
        log.Fatal(err)
    }
    log.Println(title)
}

Rust

[dependencies]
solari-browser = "0.1"
# browser automation is opt-in (pulls chromiumoxide):
# solari-browser = { version = "0.1", features = ["connect"] }

use solari_browser::{Client, ClientOptions, CreateSessionOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(ClientOptions::new(
        std::env::var("SOLARI_API_KEY")?,
        "https://api.getsolari.com",
    ))?;

    let session = client
        .sessions()
        .create(CreateSessionOptions::new().stealth(true).proxy("us"))
        .await?;

    println!("cdp: {}", session.cdp_endpoint);

    // With features = ["connect"], attach chromiumoxide:
    //   let browser = solari_browser::connect(&session).await?;

    client.sessions().release(&session.id).await?;
    Ok(())
}

C++ (17)

include(FetchContent)
FetchContent_Declare(solari_browser
  GIT_REPOSITORY https://github.com/solari-sdk/solari-browser-cpp.git
  GIT_TAG        v0.1.0)
FetchContent_MakeAvailable(solari_browser)
target_link_libraries(my_app PRIVATE solari_browser)

Blocking API over libcurl + nlohmann/json. C++ has no Playwright client, so drive the returned cdpEndpoint with a CDP library of your choice; a minimal raw-CDP helper ships behind -DSOLARI_WITH_WS=ON as an escape hatch, not an automation API.

#include <solari/browser/browser.hpp>
#include <cstdlib>
#include <iostream>

int main() {
    solari::browser::Client client({ /*apiKey=*/ std::getenv("SOLARI_API_KEY") });

    solari::browser::CreateSessionOptions opts;
    opts.stealth = true;
    opts.proxy   = std::string("us");

    auto session = client.sessions.create(opts);
    std::cout << "cdp: " << session.cdpEndpoint << "\n";

    client.sessions.release(session.id);
}

Authentication

Every SDK takes the same slr_live_ API key and sends it as Authorization: Bearer <key>. None of them read environment variables for you. Pass the key explicitly, as in the examples above. Point any SDK at a different gateway (staging, self-hosted) with its baseUrl / base_url / BaseURL option, which overrides the region default.