Solari

The fastest and cheapest infrastructure for AI agents: cloud browsers, sandboxes, and desktops behind one API, spinning up in milliseconds.

Hosted MCP Server

npx add-mcp 'https://mcp.getsolari.com/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

Connect Solari to Claude, Cursor, Windsurf or any other MCP client and your agent gets a real browser it can drive, plus sandboxes and GUI desktops it can run code in. No wrapper code to write.

The Solari MCP server exposes 49 tools over the Model Context Protocol. There are two ways to connect: a hosted endpoint (no install, works everywhere including Claude on web and mobile) or a local server via npx.

Hosted connector

Point your client at our endpoint and authenticate with your Solari API key. Nothing to install or keep running.

https://mcp.getsolari.com/mcp

Prefer the hosted endpoint

The hosted connector is generally available. The local npx server below is still there if you need to run it yourself (e.g. an air-gapped environment), but it is no longer the fallback for a flaky hosted path.

Claude

In Claude, open Settings → Connectors → Add custom connector and paste the URL above. On the authentication step, the exact field names depend on your connector dialog, but the settings you need are:

  1. Set Authentication to No sign-in. Solari authenticates with a static API key, not OAuth; leaving this on "Sign in now" or "Sign in when needed" reserves the Authorization header for OAuth and hides it from the list below.
  2. Open Request headers, choose authorization from the header-name list, and enter Bearer slr_live_… as the value, including the literal word "Bearer" and the space. Claude sends whatever you type verbatim; it does not add the scheme for you.

Don't see Request headers?

Static request-header auth is a Claude beta feature gated per organization. If your Add custom connector dialog has no Request headers section after you pick No sign-in, your organization doesn't have access to it yet; ask whoever administers your Claude org, or use the local npx server below instead, which needs no connector-dialog header support at all.

Set a default profile with a query parameter

Append ?defaultProfile=work to the connector URL (a saved profile's name, or an id) and every solari_browser_create call that omits profileId on that connection starts signed in with it; for example, https://mcp.getsolari.com/mcp?defaultProfile=work. Set directly in the MCP server URL field, so it needs no Request headers access. An explicit profileId on a call always overrides it.

The query parameter is not private the way a header is

A profile name or id in the connector URL is not a credential by itself; your API key stays in the separate Request headers section or the Authorization header, never in the URL. But most of Solari's backends, including this one, log the full request path and query string at the load-balancer level. So the profile name you choose likely ends up in our logs in the clear. If you'd rather it didn't, request approval for the x-solari-default-profile custom header instead (see Request headers above); headers aren't captured by that logging, and when both are set, the header wins.

If your organization is on Team or Enterprise, note that the connector URL (and any header) is set once by an Owner for everyone: a default configured this way is an organization default, not a per-person one. Use profileId per call if you need it to vary by person.

An Owner's org-wide header and your own query parameter can disagree, and the header will still win, but you'll be able to tell. When a session starts signed in via a configured default (not an explicit profileId), the response from solari_browser_create will include defaultOrigin: "header" | "query" | "env" alongside profileSource, naming which source actually won. If you expected your own query parameter and the response says defaultOrigin: "header", that will mean the org default overrode you, not a bug.

Connectors are shared across Chat, Code and Cowork, so you only add it once.

Prefer configuration as a file? Claude Desktop and Claude Code both read this shape:

{
  "mcpServers": {
    "solari": {
      "type": "http",
      "url": "https://mcp.getsolari.com/mcp",
      "headers": { "Authorization": "Bearer slr_live_…" }
    }
  }
}

Local server via npx

Runs on your machine and talks to Solari over the network. Requires Node 18 or newer.

{
  "mcpServers": {
    "solari": {
      "command": "npx",
      "args": ["-y", "@solarisdk/mcp"],
      "env": { "SOLARI_API_KEY": "slr_live_…" }
    }
  }
}

For Claude Desktop that file lives at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS (%APPDATA%\Claude\ on Windows), or use Developer → Edit Config. Quit and reopen the app afterwards; configuration is read at startup.

Restart, don't just close the window

Closing the Claude window leaves the app running and your connector won't load. Quit fully (⌘Q on macOS) and reopen.

Set a default profile (local server)

Set SOLARI_DEFAULT_PROFILE to a saved profile's name (an id also works, but the name is what you already see in the console) and every solari_browser_create call that omits profileId starts signed in with it; your agent stops asking which profile to use. An explicit profileId on a call always overrides the default; omit both to get a fresh browser with no profile, same as before.

{
  "mcpServers": {
    "solari": {
      "command": "npx",
      "args": ["-y", "@solarisdk/mcp"],
      "env": {
        "SOLARI_API_KEY": "slr_live_…",
        "SOLARI_DEFAULT_PROFILE": "work"
      }
    }
  }
}

solari_browser_create 's response echoes profileId and profileSource ("explicit" or "default") whenever a profile is in play, so you can tell from the transcript whether the default put you in automatically. If the configured value doesn't match any saved profile by name or id, the call fails with an error naming what it couldn't find, rather than silently starting signed out.

Get an API key

Create one from the API Keys tab at console.getsolari.com. The same slr_live_… key works for browsers, sandboxes and desktops. You'll see it once, so copy it then.

An MCP transcript is credential material

Your agent's conversation will contain session IDs that grant control of a running browser or desktop. Treat transcripts and logs accordingly, and rotate the key from the console if one leaks.

Check it worked

Ask your agent to do something that needs a browser. It should call solari_browser_create first, then navigate.

Open example.com in a Solari browser and tell me the page heading.

In Claude, the tools appear under the tool (hammer) icon once the connector is loaded.

Tools

Browser

A Solari cloud browser session, driven over CDP. Start with solari_browser_create; it returns a sessionId the other tools take.

solari_browser_create defaults differ from the REST API

Called with no arguments, this tool defaults mode to "stealth" and captcha to on. The REST POST /sessions endpoint defaults both to false. Both are plan-gated and billable (captcha solving costs money per solve); an agent calling this tool with {} silently opts into the more expensive configuration. Pass mode: "fast" and/or captcha: false to opt out.

ToolWhat it does
solari_browser_createStart a session. Options: mode (default "stealth"), proxy, captcha (default on), recording, profileId
solari_browser_navigateGo to a URL; returns final URL, title and status
solari_browser_read_pagePage text, links, or HTML
solari_browser_screenshotJPEG of the current page
solari_browser_click / solari_browser_type / solari_browser_keyInteract by CSS selector or coordinates
solari_browser_evaluateRun a JavaScript expression in the page
solari_browser_replay_urlReplay URL for a session created with recording: true
solari_browser_login / solari_browser_await_loginHand off to a human for a login the agent can't complete itself, then wait for it to finish
solari_browser_autologin_status / solari_browser_autologin_siteSee which password managers and sites are set up for automatic sign-in, and set a site to sign in with a connected password manager
solari_browser_save_profile / solari_browser_profilesSave the session's cookies/storage as a profile, or list saved profiles
solari_browser_create_profile / solari_browser_delete_profileCreate an empty saved profile, or permanently delete one with its stored sign-in state (only when the user asked for it)
solari_browser_edit_profile / solari_browser_finish_profile_editOpen a saved profile for a person to edit (returns a link that is valid for 30 minutes and a handoffId), then finish with save: true to keep the changes or save: false to discard them
solari_browser_closeRelease the session

Sandboxes and desktops

solari_sandbox_create gives you a headless microVM; solari_desktop_create gives you a GUI one and returns a streamUrl you can watch over noVNC. The GUI tools (screenshot, click, type, open) require a desktop.

ToolWhat it does
solari_sandbox_create / solari_desktop_createCreate a VM; returns a sessionId
solari_exec / solari_run_command_bgRun a shell command, blocking or in the background
solari_command_status / solari_command_killCheck a background command (running, exitCode, the tail of stdout and stderr; pass waitMs to wait up to 30 s for it to exit), or send it a signal (default SIGTERM). Only commands started through this server are tracked
solari_run_codeRun code (Python by default), including charts
solari_read_file / solari_write_file / solari_list_filesGuest filesystem
solari_get_preview_urlPublic URL for a port inside the VM (e.g. a dev server)
solari_screenshot / solari_click / solari_type / solari_key / solari_open_app / solari_mouse_move / solari_mouse_down / solari_mouse_up / solari_dragControl the desktop GUI; the mouse tools give fine-grained control (press, move, release, or a single drag gesture) for interactions solari_click can't express
solari_pause / solari_resumePause a session (RAM and disk are saved and the slot is freed, so it stops costing compute; the id stays valid and any later tool call wakes it), or resume it explicitly. Background commands do not survive a pause
solari_snapshot / solari_snapshot_list / solari_snapshot_delete / solari_revertCheckpoint a running session (it keeps running; snapshots are stored and billed until deleted), list the org's snapshots (newest first), delete one, or roll a session back in place to a snapshot (everything since is lost). Boot a new session from a snapshot with fromSnapshot on the create tools
solari_list / solari_connect / solari_killList VMs, re-attach to one by id (resuming it if paused), or destroy it

Sessions and cost

Every *_create call starts a billable session, exactly as it would through the SDK; see Plans & Pricing. Two things worth knowing:

  • Browser sessions are released when the agent calls solari_browser_close. The hosted server does not release an abandoned one for you: it keeps holding a concurrency slot until the gateway ends it at your plan's maximum session length, so ask the agent to close what it opens.
  • Sandboxes and desktops idle-pause rather than being destroyed, so their state survives; solari_connect re-attaches and resumes. Use solari_kill when you're done with one.

Your plan's concurrency limits apply, so an agent that opens sessions without closing them will eventually see a concurrency error.

Environment variables

For the local server:

VariableDefaultPurpose
SOLARI_API_KEYNoneRequired. Your API key
SOLARI_BASE_URLhttps://api.getsolari.comSandbox and desktop API
SOLARI_BROWSER_URLSOLARI_BASE_URLBrowser API, when it differs
SOLARI_BROWSER_API_KEYSOLARI_API_KEYA separate key for the browser API, if yours are split
SOLARI_DEFAULT_PROFILENoneName or id of a saved profile used by solari_browser_create when the call gives none

Running the HTTP server yourself

The package ships the same server that backs mcp.getsolari.com as dist/http.js. It speaks Streamable HTTP, so any client that can send a bearer token can use it. Install the package and start it:

npm install @solarisdk/mcp
PORT=8080 node node_modules/@solarisdk/mcp/dist/http.js

Or run it in a container. The server needs no build step beyond the install:

FROM node:22-slim
WORKDIR /app
RUN npm install --omit=dev @solarisdk/mcp
ENV PORT=8080
EXPOSE 8080
USER node
CMD ["node", "node_modules/@solarisdk/mcp/dist/http.js"]

The server listens on PORT (default 8080) and answers three paths:

  • POST /mcp: the MCP endpoint. Every request must carry Authorization: Bearer slr_live_…; a missing or invalid key is a 401. Any other method on /mcp is a 405.
  • GET /health and GET /healthz: return {"ok":true,"tenants":N,"stateless":true}, with no key needed. Use either as the container health check.

The server is stateless: there is no mcp-session-id, every request authenticates on its own, and any replica can serve any request. The API key is the tenant boundary, so one server can serve several keys. These environment variables configure it:

VariableDefaultPurpose
PORT8080Listen port
SOLARI_BASE_URLhttps://api.getsolari.comSandbox and desktop API
SOLARI_BROWSER_URLSOLARI_BASE_URLBrowser API, when it differs
MAX_SESSIONS500Most distinct API keys one process serves at once; past it a new key gets a 503
MAX_SESSIONS_PER_KEY20Most live sandboxes, desktops and browser sessions one key may hold through one process; past it new work gets a 429 until you close or kill one
TENANT_IDLE_SWEEPoffSet to single-replica-only to release a key's sessions after it has been idle (see the warning below)
SESSION_IDLE_MS1800000 (30 min)Idle time before the sweep releases a key. Does nothing unless the sweep is on

The idle sweep is off by default

With the sweep off, a conversation that ends without calling solari_browser_close or solari_kill leaves its browser session holding a concurrency slot until the session expires. The MCP server sends no timeout, so that is your plan's maximum session length: 60 minutes on Free, 5 hours on Starter, 24 hours on Professional, and 365 days on Team and Enterprise. The sweep fixes that, but it is only safe with exactly one replica: each replica only sees its own traffic, so with two or more it will tear down sessions that another replica is still driving. Turn it on only if you run a single instance.

Request bodies are limited to 4 MiB. To give every session of a connection a default profile, add ?defaultProfile=work to the connector URL, or send the X-Solari-Default-Profile header (the header wins when both are present). The query string can end up in the access logs of any load balancer in front of the server, so prefer the header where your client lets you set one.

Other MCP clients

Cursor, Windsurf and Claude Code use the same two configuration shapes above. In Claude Code you can add the hosted connector directly: claude mcp add --transport http solari https://mcp.getsolari.com/mcp \\ --header "Authorization: Bearer $SOLARI_API_KEY". Grok needs no server-side build on our end either; it speaks the same Streamable HTTP MCP transport with the same header-based auth: grok mcp add --transport http solari https://mcp.getsolari.com/mcp \\ --header "Authorization: Bearer $SOLARI_API_KEY".

Profiles follow the key, not the client

Browser profiles are scoped to your organization's API key, not to whichever MCP client created them. Save a login in a profile from Claude and it is immediately usable from Grok, Cursor or any other client authenticated with the same key.