Does Nstbrowser Run on Linux?
Yes. nstbrowser linux support comes in three shapes: a Chromium-based desktop app listed for Windows, macOS and Linux, a Docker image (nstbrowser/browserless) you self-host on any Linux server, and cloud capacity for running scripts and tasks. The desktop app suits hands-on work, the container suits unattended work, and entry starts with a free plan, with paid tiers from $29.90/mo. What is missing is a step-by-step official install guide for the Linux desktop build, so expect self-directed setup.
📌 TL;DR Executive Summary
- Core Takeaway: Nstbrowser ships a Linux desktop build and a self-hosted container, nstbrowser/browserless, that needs a TOKEN environment variable and listens on port 8848 by default.
- Key Risk/Challenge: Launches are metered, not unlimited. The free plan allows 30 standard profile launches a day, and overage at roughly a cent per launch can outgrow the subscription itself.
- Recommended Solution: Desktop app for interactive account work, container for work that runs while nobody is watching. If your nstbrowser linux need is people logging into client accounts they manage, Send.win covers it with a native Linux app and a cloud browser.
What Nstbrowser Is and Which Linux Options You Get
Nstbrowser is a browser profile manager: a Chromium-based browser in which each profile keeps its own cookies, local storage, cache, login sessions, fingerprint values and proxy. Linux is on the supported platform list, but “supported” means three different delivery routes, and each nstbrowser linux route asks something different of you.
The Linux desktop app
The download page lists a Chromium-based build for Windows, macOS and Linux with customisable fingerprints and per-profile proxy settings. What you get is the interface users see on other platforms: a profile list, proxy fields, and a launch button that opens a real browser window on your desktop.
The documentation covers the fingerprint browser, an API reference and an SDK, but it does not publish a step-by-step Linux desktop guide covering dependencies, package formats and troubleshooting. If you are comfortable on desktop Linux you will get there; if you are not, budget real time for it or take the container route instead.
The self-hosted Docker container
The nstbrowser/browserless image is a Linux container built on Nstbrowser’s fingerprint library and aimed at headless work rather than clicking. It requires a TOKEN environment variable holding your API key, reads SERVER_PORT and DATADIR for configuration, listens on port 8848 by default and weighs roughly 568 MB. That is the route most Linux users actually want, because profile management becomes an HTTP service you can call from cron, a CI runner or a queue worker with no desktop environment involved.
Cloud capacity and dedicated servers
If you would rather not run infrastructure, Nstbrowser sells cloud cluster capacity for running scripts and tasks, plus dedicated server instances, and the pricing page lists a Container feature alongside the standard plans. From a Linux workstation that mostly means pushing long-running jobs off your own machine without becoming a Docker administrator.
How a Linux Nstbrowser Setup Actually Works
Every nstbrowser linux setup follows the same model: one profile equals one browser environment. Cookies, local storage, cache, IndexedDB and the fingerprint values the browser reports stay inside that environment, and the proxy is attached at profile level so the network path travels with the session. On Linux the only real difference is how you reach it — a window, or an HTTP call.
The container is an HTTP control plane
The API reference documents endpoints for browsers, profiles, groups, proxies, tags and local-data clearing, plus CDP connect endpoints. The CDP endpoints matter most for automation: they hand back a WebSocket address you drive with Selenium, Puppeteer, Playwright or raw Chrome DevTools Protocol. There is also a dedicated CDP function for updating proxy context mid-session, useful when one workflow has to span regions.
If you build this from scratch, the walkthrough for calling the Nstbrowser API from Python covers request shapes and the first profile launch.
Standard Profiles vs Once Profiles
The two profile types behave differently, and the difference affects both your scripts and your bill.
| Behaviour | Standard Profile | Once Profile |
|---|---|---|
| Cookies, logins and local data between launches | Retained | Cleared when the session ends |
| Fingerprint settings between launches | Retained | Not carried over with the session data |
| Overage price per launch | Higher of the two rates | Lower of the two rates |
| Best for | Client accounts, ongoing sessions, roles you return to | One-off checks, short verification runs |
Proxies travel with the profile
Nstbrowser’s homepage says built-in proxies can be assigned per profile so they line up with fingerprints and sessions, and it sells residential, IPv6 and datacenter traffic. On a Linux host that combination lets one container serve profiles reaching the web from different exit IPs — useful when you are checking how a page renders or prices in several regions. If proxy cost is the line item that keeps moving, this comparison of residential proxies ranked by cost per GB puts the per-gigabyte numbers side by side.
Who Actually Needs Nstbrowser on Linux
Linux is where scheduled work lives: cron jobs, CI runners, containers on a VPS. If your browser work is unattended — pulling structured data from pages you are authorised to access, checking that a client’s checkout renders correctly in three regions, running QA passes as different user roles — a headless container is the natural home for it.
The second group is larger and less technical. Agencies, sellers running several storefronts, social media managers and support teams mostly need humans to log into accounts they manage without stepping on each other’s sessions. For them the Linux question is simpler: does the app run on my machine, and can a colleague open the same profile without a password pasted into chat?
The two needs pull in opposite directions. Scripted stacks optimise for throughput — launches per day, concurrent sessions, API surface. Human workflows optimise for session continuity and handover, which is why teams that start with automation often add something a person can actually drive; the case for a cloud browser with a UI mode is exactly that gap.
One constraint applies to both. A profile manager does not change what a platform allows. If a marketplace requires approval for an additional seller account, or a social platform expects agency work to run through Business Manager roles, that is the route — no profile or proxy setup replaces it. When an account is restricted, the fix is the platform’s own appeal or verification process.
Step-by-Step: Self-Hosting Nstbrowser on Linux
The container path is the one worth documenting properly, because the desktop path is a download and a double-click. Work through this in order.
- Create your Nstbrowser account and copy the API key — this becomes the TOKEN value.
- Install Docker Engine on the host and confirm the daemon is running with
docker info. - Pull the image:
docker pull nstbrowser/browserless. - Start the container with TOKEN, SERVER_PORT, DATADIR and a bind mount so profile data survives a restart.
- Confirm something is listening on 8848 before writing a single line of automation.
- Create a profile through the API, attach the proxy you want, and note the profile ID.
- Request a CDP connect URL for that profile and pass it to Playwright, Puppeteer or Selenium.
- Track launches per day from day one so you spot overage before the invoice does.
docker pull nstbrowser/browserless
docker run -d \
--name nstbrowser \
--restart unless-stopped \
-p 127.0.0.1:8848:8848 \
-e TOKEN="YOUR_API_KEY" \
-e SERVER_PORT=8848 \
-e DATADIR=/data \
-v /srv/nstbrowser:/data \
nstbrowser/browserlessThe bind mount matters more than it looks. Without -v, recreating the container wipes the data directory and every stored login with it. Once the container is up, a quick check tells you whether the service is answering:
curl -I http://127.0.0.1:8848Any HTTP response means the server is listening; connection refused means the port mapping or the process is wrong. From there, the CDP endpoint returned by the connect call is all Playwright needs.
from playwright.sync_api import sync_playwright
# The connect call for the profile returns a WebSocket URL in this shape
CDP_URL = "wss://cdp-host-for-your-profile/devtools/browser/<session-id>"
with sync_playwright() as p:
browser = p.chromium.connect_over_cdp(CDP_URL)
context = browser.contexts[0]
page = context.new_page()
page.goto("https://example.com")
print(page.title())
browser.close()That snippet attaches rather than launches. The container already started a browser for the profile, which is why the profile’s cookies and proxy settings apply without extra configuration in your script.
Nstbrowser Pricing and Launch Limits
Every plan is metered on profile launches rather than wall-clock time, so nstbrowser linux budgeting works nothing like the per-seat software you may be used to. These are the published tiers.
| Plan | Price | Saved profiles | Standard launches/day | Team members | Proxy traffic |
|---|---|---|---|---|---|
| Free | $0 | 500 | 30 | 3 | Not listed |
| Starter | $29.90/mo | 20,000 | 3,000 | 20 | 1 GB/mo each of residential, IPv6 and datacenter |
| Growth | $49.90/mo | 100,000 | 20,000 | 50 | 1.5 GB/mo each |
| Scale | $89.90/mo | 500,000 | 50,000 | 100 | 2 GB/mo each |
Beyond the included allowance, billing moves to per-unit rates: roughly a cent to a cent and a half per standard profile launch, $0.004 to $0.008 per Once Profile launch, and $1.50 to $1.80 per GB of residential proxy traffic depending on your tier. That spread explains the shape of the free plan — 500 saved profiles but only 30 launches a day. Storing profiles costs almost nothing; running them costs money.
An example makes it concrete. A Linux box cycling 5,000 extra standard launches in a month lands around $50 to $75 at those rates, which is more than the Starter subscription itself. A retry loop left running over a weekend shows up as a line item. The full breakdown of Nstbrowser pricing and launch limits goes deeper on how the tiers behave at volume.
Billing rules that catch people out
- Payment is by credit or debit card and PayPal; account credits cannot be used for subscriptions.
- Upgrades take effect immediately — you pay the difference for the current term.
- Downgrades are not supported mid-term. You can pre-configure the plan for the next billing cycle, but you cannot drop a tier before the term ends.
How Send.win Helps With Nstbrowser Linux
Send.win is a browser profile manager for professionals and teams: every account gets its own isolated browser profile.
- Isolated profiles – separate cookies, storage and sessions per profile
- Fingerprint protection – each profile keeps its own consistent browser fingerprint, so profiles never share one browser identity
- Desktop app + cloud browser – native app for Windows, macOS and Linux, or run profiles in the cloud with no install
- Residential proxies included – on Pro and Team, with timezone and locale matched to the proxy
- Team sharing – share a signed-in profile with a teammate without sharing the password
Try the free cloud demo — no install — or download the desktop app. Paid plans start at $19/month, and your first card purchase is covered by a 7-day money-back guarantee (see pricing).
Common Mistakes on a Linux Host
Most failures reported on Linux come from configuration rather than the browser itself.
- Starting the container without TOKEN. The image expects the variable; without it the service cannot authenticate your account and API calls fail.
- Exposing port 8848 publicly. Publishing to 0.0.0.0 on a cloud host means anyone who finds the port can control your profiles.
- Skipping the data volume. A container without a mounted DATADIR loses stored logins when it is recreated, turning a routine upgrade into a re-authentication session.
- Using Once Profiles for work that must stay signed in. They clear cookies and local data when the session ends — that is the point of them, and the wrong choice for a client account you open daily.
- Leaving retry loops unbounded. A failing script that relaunches a profile every 30 seconds consumes launches at a rate your plan was never sized for.
- Judging the image by a stale listing date. Docker Hub entries often show old “last updated” stamps while newer tags sit alongside; check the tag list before concluding the project is dormant.
Where Send.win Fits — and Where It Doesn’t
Nstbrowser is built for teams whose browser work runs on servers rather than on someone’s desk. That need shapes the whole product: a self-hosted container, cloud capacity, per-launch metering and documentation written for developers. It is a specialist tool, and it is good at the job it was built for.
Send.win is a different kind of tool. It is for a person who opens a profile and works in it, and the design decisions follow from that.
Sendwin Browser is a native desktop app for Windows, macOS and Linux — on Linux it ships as an AppImage or a .deb — built on Chromium. There is also a cloud browser that runs profiles on Send.win’s server in Helsinki, Finland, with nothing to install. Each profile keeps its own cookies, storage, sessions, fingerprint settings and proxy, handled inside the browser engine as privacy protection, the same principle as the fingerprinting protection in Firefox or Brave applied per profile.
Be clear about the boundary: Send.win has no developer interface, no way to launch profiles from a terminal and no unattended mode on any plan. A profile opens because a person opens it, in the desktop app or in the cloud browser. If that sounds limiting, it is the right limitation for the audience — teams that manage client accounts, storefronts and support queues by hand.
The collaboration model is the part teams notice. Share a profile with a paid teammate and it opens already signed in, without a password changing hands. Share live cloud sessions when two people need the same screen, and cloud sync makes logins follow you across devices. Pro covers 150 saved profiles, 5 GB/month of residential proxy bandwidth and 6 seats; Team covers 500 profiles, 20 GB/month and 16 seats, with up to 50 profiles open at once on either plan.
| Requirement | Nstbrowser | Send.win |
|---|---|---|
| Linux desktop app | Chromium-based build listed for Linux | Sendwin Browser (AppImage / .deb) |
| Self-hosted option | Container image you run on your own server | Not offered |
| Cloud option | Cloud cluster capacity and dedicated servers | Cloud browser in Helsinki, EU — no install |
| How a profile opens | From the app, or through the container’s HTTP service | By a person, in the desktop app or the cloud browser |
| Team seats | 3 free; 20 / 50 / 100 on paid plans | 6 on Pro, 16 on Team |
| Entry price | Free plan; paid from $29.90/mo | $19/mo Pro; free cloud demo, 10 minutes a day |
The split is straightforward. If profiles have to run while nobody is watching, Nstbrowser is built for that. If people need to log into accounts they own or are authorised to manage — on a Linux laptop or through a cloud browser with nothing to install — Send.win is built for that. Both are bound by the same rule: accounts you own or are authorised to manage, and each platform’s terms.
🏆 Send.win Verdict
If your Linux question is really “can my team work in isolated profiles on the machines we already have”, Send.win answers it without a Docker daemon. Sendwin Browser installs natively on Linux as an AppImage or .deb, the cloud browser needs no install at all, and paid-to-paid profile sharing opens a client account already signed in — no password in a chat thread. It is a hands-on tool rather than a developer platform, which is why it stays simple for people whose job is managing accounts rather than running infrastructure.
See Send.win plans — Pro from $19/mo or $83.88/yr with residential proxies included, backed by a 7-day money-back guarantee on your first card purchase; the free cloud demo gives you 10 minutes a day with nothing to install.
Frequently Asked Questions
Does Nstbrowser run on Linux?
Yes. Support for nstbrowser linux comes in three shapes: a Chromium-based desktop build listed for Windows, macOS and Linux, a Docker image called nstbrowser/browserless for Linux servers doing headless work, and cloud cluster capacity with dedicated servers. That lets you pick between a local window, a self-hosted container and hosted capacity.
How do I install Nstbrowser on Linux?
For desktop use, download the Linux build from the vendor’s site and run it. There is no detailed official Linux installation guide covering dependencies and package formats, so expect self-directed setup. For server use, install Docker Engine, pull nstbrowser/browserless and start it with your TOKEN, a SERVER_PORT value and a mounted DATADIR.
Can I self-host Nstbrowser with Docker?
Yes. The nstbrowser/browserless image is built on Nstbrowser’s fingerprint library, requires a TOKEN environment variable holding your API key, and listens on port 8848 by default. It is configurable through SERVER_PORT and DATADIR, and the image is around 568 MB. Mount a host directory to keep profile data across container restarts.
Is Nstbrowser free to use?
There is a free plan: 500 saved browser profiles, 30 standard profile launches per day and 3 team members, with pay-as-you-go overage beyond that. Paid plans start at $29.90/mo for Starter. Some third-party listings describe a free trial instead of a free plan, so confirm the current terms on the vendor’s own pricing page.
Does Nstbrowser support Puppeteer and Playwright?
Yes. The API reference includes automation guides for Selenium, Puppeteer, Playwright and raw Chrome DevTools Protocol. The CDP connect endpoints return a WebSocket address you attach to rather than launching a new browser, and there is a dedicated CDP function for updating proxy context during a session.
What happens if I exceed my Nstbrowser profile launches?
Overage is billed per unit rather than blocked. Standard profile launches cost roughly a cent to a cent and a half each, Once Profile launches $0.004 to $0.008, and residential proxy traffic $1.50 to $1.80 per GB depending on tier. At a few thousand extra launches a month, the overage can exceed the subscription price.
Can I downgrade my Nstbrowser plan?
Not mid-term. Upgrades take effect immediately and you pay the difference for the current period, but a downgrade only happens by pre-configuring the plan you want for the next billing cycle. Subscriptions are paid by card or PayPal, and account credits cannot be applied to them.
Can I use Send.win on Linux instead?
Yes, if your work is people managing accounts rather than jobs that run on a server. Sendwin Browser runs natively on Linux as an AppImage or .deb, and the cloud browser needs nothing installed at all. Send.win is a hands-on tool — there is no developer interface and no way to run profiles without a person driving them — so it does not replace a self-hosted container for teams that need that.