Hidemyacc Alternatives: $10 Entry, $99 to Script

The first price is the one on the pricing card. It buys a window you click in. The second price is the cheapest plan on which a for loop can open that window, read something, and close it again. Almost nobody prints the second price, because almost nobody separates the two concepts on a feature matrix.

This matters more than profile count, and much more than fingerprint marketing, for a specific reason: the two prices diverge by different amounts at different vendors, and the divergence is not correlated with quality. One vendor here ships a scriptable API on a permanently free plan. Another charges nearly ten times its entry price for the same capability. Between those two extremes, the feature lists look nearly identical, because both vendors write "automation" in the same font.

So the useful question is not "which tool is best". It is "what is the smallest cheque that makes this tool programmable, and what exactly do I get for it". Answering that requires reading three sources per vendor rather than one: the pricing card, the feature comparison matrix lower down the same page, and the API documentation. Those three disagree more often than you would expect. On Hidemyacc they disagree with each other today, which is where this post starts.

A note on what is deliberately out of scope. Fingerprint depth, Chromium version cadence and detection scores are real axes, and nothing below ranks on them. Where a vendor publishes a detection claim, it is quoted as that vendor's own unverified claim, never as fact. Nobody in this comparison, including SparkProxy, has published a reproducible measurement that would let you rank five antidetect browsers by block rate on the same targets on the same day, so treating any such figure as settled would be dishonest. The gate is measurable. The stealth is marketing until somebody shows the harness.

One more framing point. An antidetect browser and a proxy pool solve different halves of the same problem, and the bill arrives from two places. If you have not separated those two line items yet, antidetect browsers versus proxies draws the boundary. Everything below holds the proxy line constant so the browser line is the only thing moving.

"Automation" on an antidetect browser pricing page refers to at least four unrelated capabilities. They are not interchangeable, they do not substitute for one another, and vendors blur them because blurring them makes a cheap plan look complete.

The fourth row is the one that does the work in a sales conversation. A drag-and-drop editor with loops and conditions genuinely automates repetitive clicking, and for a lot of multi-account work that is sufficient. What it cannot do is sit in a repository, run in CI, be diffed in a pull request, or be invoked by a scheduler that also talks to your database. The moment your workflow has a second system in it, no-code RPA stops being automation and becomes a GUI you have to operate.

There is now a fifth shape worth naming, because it appeared across this category during 2025 and 2026: an MCP server that lets an AI agent call the vendor's local API in natural language. AdsPower publishes a guide for one, describing it as built with TypeScript, Playwright and NPM. That is a wrapper around row one, not a replacement for it. If the underlying local API is gated behind a paid tier, the MCP server is gated behind the same tier, and a pricing page that advertises AI agent support without saying which plan carries the API is telling you less than it appears to.

When you read a feature matrix from here on, the test is mechanical. Find the row that says API. Find which columns carry a mark. Everything else in the automation group can be present on the cheapest plan and still leave you unable to write a single line of code.

Hidemyacc publishes five standard plans plus two extras. Read from its pricing page on 9 October 2026, with the monthly figure first and the per-month equivalent on yearly billing in brackets. The page labels that second column "Yearly Price Discount 50%".

Every plan carries a 7-day free trial, and the homepage states the trial includes 30 profiles. Base and above also allow unlimited paid sub-accounts, which is what the $5 Share plan is for. Those prices come from the Offer objects in the page's own structured data, so they are not a client-side rendering artefact; Mini - Monthly is 5, Base - Yearly is 25, and so on through Business - Monthly at 199, all in USD.

Now the automation group from the same matrix, which is where the post earns its title:

Six of seven automation rows are universal. Hidemyacc's own description of the first one reads "Access a wide range of automation scripts for platforms like Facebook, Amazon, and more", and its documentation says the visual builder "provides 7 different command groups for you to build scripts to fit your needs. Simply drag and drop these commands to create your own automation script without needing to know how to code." The seven groups are Variables, Browser, Interaction, Condition, Loops, Facebook and Files, the last of which covers Google Sheets and Excel. There are docs pages for importing and exporting scripts and for running and scheduling them.

That is a real product, and at $10 for five profiles it is cheap. It is also entirely row four of the taxonomy above. The one row that moves you into row one, API Access, is the single row Mini and Starter do not have. Two other gates sit nearby and are worth knowing before you commit: Import/Export Profile appears only on Business at $199, and iOS and Android fingerprints appear only from Base upward. So the plan that lets you take your profiles out in bulk is the most expensive one, which is a migration cost you pay on the way out rather than on the way in.

Here is the part worth a support ticket before you pay. Hidemyacc's pricing page states two different automation floors in two different places.

The per-plan feature cards near the top list "API Access" as a bullet on Base ($49), Team and Business. Mini and Starter do not list it. Scroll to the full comparison matrix on the same page and the API Access row is blank for Mini, blank for Starter, blank for Base, and ticked only for Team and Business. Same page, same day, same feature name, two answers: $49 or $99.

The documentation settles it, and it does so in the most concrete way available. The Start Profile reference for the Hidemyacc 3.0 API documents the endpoint as POST http://127.0.0.1:2268/profiles/start/:profileID and includes an error table. The row reads:

402    API supported from Team plan

An HTTP 402 with that message is not an interpretation of a feature matrix. It is the runtime behaviour you will observe on Base. Two of the three sources agree on Team, one of them is the API itself, and the third is a marketing card. Budget $99.

Treat the $49 card as a documentation defect rather than an offer, and if you have already bought Base expecting an API, that error string is the thing to paste into the ticket. We have not tested the gate on a live Base subscription, so we are reporting what three of Hidemyacc's own surfaces say rather than what a billing system did.

One related detail about the API surface itself. Hidemyacc documents two generations side by side: section 12.9 covers the "Hidemyacc 2.0 API" and section 13 covers the 3.0 API, with the 3.0 profile endpoints split into Create Marco Profile and Create Ghosty Profile variants plus matching update calls. Running two documented API generations at once is normal for a tool mid-migration, but it means any code you write needs a note about which generation it targets, and any example you find on the internet needs the same note before you trust it.

The three numbers that matter per vendor are the cheapest paid plan, the cheapest plan a language can drive, and the ratio. Where the free plan already carries an API, the ratio is zero, because the gate costs nothing to cross.

# gate_multiple.py  -  cheapest paid tier vs cheapest tier a language can drive.
# Every figure read from the vendor's own pricing page on 9 October 2026, USD, month-to-month.

VENDORS = [
    # vendor,        paid entry $, profiles, script floor $, profiles, surface you get
    ("Hidemyacc",      10.00,     5,   99.00,  300, "local REST -> CDP wsUrl"),
    ("Nstbrowser",     29.90, 20000,    0.00,  500, "local REST + CDP websocket"),
    ("GoLogin",         9.00,    10,    9.00,   10, "cloud REST, 300 req/min"),
    ("Incogniton",     19.99,    10,   29.99,   50, "Selenium + Puppeteer + REST"),
    ("Undetectable",   34.00,    50,   34.00,   50, "local REST"),
]


def multiple(entry, floor):
    """How many times the entry price you pay before anything is scriptable."""
    if floor == 0.0:
        return 0.0            # the free tier already scripts, so the gate costs nothing
    if entry == 0.0:
        return float("inf")   # no paid tier below the gate to compare against
    return floor / entry


print(f"{'vendor':<13}{'paid entry':>11}{'script floor':>14}{'multiple':>10}  surface")
for name, entry, _ep, floor, _fp, surface in VENDORS:
    m = multiple(entry, floor)
    shown = "inf" if m == float("inf") else f"{m:.1f}x"
    print(f"{name:<13}{entry:>11.2f}{floor:>14.2f}{shown:>10}  {surface}")

worst = max(VENDORS, key=lambda v: multiple(v[1], v[3]))
print(f"\nwidest gate: {worst[0]} at {multiple(worst[1], worst[3]):.1f}x, "
      f"{worst[1]:.0f} to {worst[3]:.0f} USD a month")

Output:

vendor        paid entry  script floor  multiple  surface
Hidemyacc          10.00         99.00      9.9x  local REST -> CDP wsUrl
Nstbrowser         29.90          0.00      0.0x  local REST + CDP websocket
GoLogin             9.00          9.00      1.0x  cloud REST, 300 req/min
Incogniton         19.99         29.99      1.5x  Selenium + Puppeteer + REST
Undetectable       34.00         34.00      1.0x  local REST

widest gate: Hidemyacc at 9.9x, 10 to 99 USD a month

Three of the five put the API on their cheapest paid plan, so for them the gate is free and the only question is whether that plan holds enough profiles. Incogniton charges a 1.5x step. Hidemyacc charges 9.9x. Nstbrowser inverts the question entirely by putting the API on a plan that costs nothing, which is why its paid entry sits above its scripting floor in that table.

The reason this column is more useful than a price-per-profile column: price per profile improves monotonically as you buy more, so it always recommends the biggest plan, which you already knew. The multiple tells you something you cannot guess, namely how much of your budget is being spent on the privilege of writing code rather than on capacity. At 9.9x, roughly nine tenths of a Hidemyacc Team subscription is buying profile headroom you may not need, bundled with the one feature you do.

Selected by the axis above and nothing else: the cheapest published plan whose automation a language can drive, with the surface named rather than called "automation".

Nstbrowser is the only one here whose free plan is scriptable. Its pricing page ticks both the API row and the RPA row in all four columns, free Standard included, and the Standard column carries 500 browser profiles, 3 team members and 30 standard profile launches a day. The API documentation names the server as http://localhost:8848/api/v2 with an x-api-key header, and the CDP section documents a websocket at /connect/{profileId} described as "Launch and connect to a running browser or a created profile". Options are passed as a URL-encoded JSON string in a config query parameter, because, in the docs' own words, "you can't carrying a Request Body in a WS/GET request". The docs are specific about versions in a way that suggests they are maintained: GetProfilesByCursor is marked "Nstbrowser 1.17.3+ required", builtinProxy is "supported in v1.19.0+", and forceUAVersion is "supported in v1.22.4+" with a warning that mismatching the kernel version "may cause fingerprint inconsistencies or website compatibility issues".

The catch is the launch cap, and its semantics are unusual enough to quote. Nstbrowser's page says "Launching the same profile multiple times in a single day only counts as one launch, and the profile launch count resets daily." So the free plan's 30 per day is a cap on distinct profiles touched, not on runs. Thirty profiles hit a hundred times a day is inside the cap; thirty-one profiles hit once is not. Beyond it, "Any excess usage will be billed based on a per-launch price and added to your invoice", and the Standard column prints $0.01 per standard profile launch. One oddity on their own page, worth noticing before you pick a tier: the paid Starter plan at $29.90 lists a higher overage, $0.015 per launch, than the free plan does.

GoLogin has the cheapest paid API and the smallest allowance behind it. Its docs pricing page lists Professional at "$9/month+" with 10, 50 or 100 profile options and API at "300 RPM", rising through Business at $119 with 500 RPM, Enterprise at $299 with 800 RPM, and Custom from $449 with 1,200 RPM. The Forever Free plan gives three profiles and lists API access among the features explicitly not available. The "+" in "$9/month+" is doing real work: the page does not print a separate figure for the 50-profile or 100-profile variant, so $9 is the 10-profile price and anything larger is a quote. Note also that this is a cloud REST API over profiles rather than a local one, and that team members stay at one on every tier above Professional, which is its own kind of ceiling. If a cloud-hosted profile model suits you better than a local app, cloud antidetect browsers covers that trade in general terms.

Incogniton is the one that names the bindings instead of saying "API". Its Entrepreneur plan, $29.99 month-to-month or $20.99 a month on six-month billing, carries 50 profiles and lists both "Selenium / Puppeteer integration" and "API Access" as separate features. Starter Plus below it ($19.99, or $13.99 on six-month billing, 10 profiles) carries neither, which is the 1.5x step in the table above. The free tier gives 10 profiles for two months and then drops to three, and the page lists REST API access and Selenium/Puppeteer integration among the things the free version excludes, alongside the Cookie Collector, Synchronizer and profile transfer. Naming the frameworks is a small thing that tells you something real: a vendor that documents WebDriver bindings has usually been asked to support them by people writing tests, which is a different user than one who wants a visual editor.

Undetectable publishes the clearest local-profile story and the highest free-tier ceiling. Base at $34 a month ($412 a year) gives 50 cloud profiles, unlimited local profiles, one user, and Local API. Professional at $69 ($832 a year) doubles cloud profiles to 100 and allows two users with more at $20 each to a hundred. Custom at $139 ($1,672 a year) reaches 10,200 cloud profiles at $100 per additional thousand, with extra users at $15. The free plan is unusually concrete: up to 5 cloud profiles at a time, a monthly limit of 50 profile creations, one user session, 10 browser configurations, and extension support, with extra profiles at $10 per 10 up to a 45 ceiling. The Local API row appears on Base, Professional and Custom. It does not appear on the free plan, so we are listing Undetectable's scripting floor as $34 rather than $0.

AdsPower belongs in this conversation but cannot be ranked on it, and the reason is instructive. Its pricing page shows a permanent free plan with 2 profiles and one super-administrator, then Professional, Business and Enterprise above it. The Local API row prints three values, "300 requests/minute", "900 requests/minute" and "1500 requests/minute", which line up with the three paid tiers and leave the free column empty. Every dollar figure on that page renders client-side; fetched without JavaScript on 9 October 2026 the prices come back as placeholder dashes, so there is no primary price to quote. Separately, AdsPower's own marketing pages state that the free plan includes Local API access at 120 requests a minute. That is AdsPower's claim on a blog page, and it contradicts the empty free column on the page you actually pay against. We are attributing rather than asserting, and if the free local API matters to your decision it is a one-email question. Its help centre adds a permissions wrinkle that applies to teams on any plan: "The super admins have access to API by default. If you are a team member, please make sure your manager or admin has assigned you this permission."

Three names you will see in every other list are absent here on purpose, because the axis did not select them. Multilogin, Kameleo and Dolphin Anty are all credible tools with real fingerprint engineering behind them; none of them is the cheapest route to a scriptable tier, which is the only thing this post ranks. If your constraint is fingerprint depth rather than the price of a for loop, rank on fingerprint protection instead and ignore everything above. And if you are mainly trying to avoid paying at all, the trade-offs at the free end are catalogued in free antidetect browsers.

Hidemyacc's documentation points to a GitHub repository for integration code. Section 13.3 reads "Hidemyacc API Examples for Puppeteer/Nodejs, Selenium (C#, Python)" and links github.com/hidemyacc/hidemyacc.

Queried through the GitHub API on 9 October 2026, that repository is C#, has 15 stars and 2 forks, zero open issues, was created on 29 September 2021, has published zero releases, is not archived, and carries no licence file. Its most recent commit is 25518ba, dated 22 November 2023, with the message "Create Record-Automation-with-easy.md". So the official examples for the API you would be paying $99 a month to reach have not been touched in nearly three years.

This is not a Hidemyacc-specific failing, and the symmetry is the point. github.com/AdsPower/localAPI, described by its own README as supporting Selenium and Puppeteer, is JavaScript, has 106 stars and 16 forks, two open issues, zero releases, is not archived, and last saw a commit on 5 December 2023 (1ff41fc, "Update README.md"). Both repositories are stale by the same measure, read the same way, on the same day.

What that tells you is narrow and worth being precise about. A stale examples repository does not mean the API is broken; the API ships inside the desktop app and gets updated with it, and both products have shipped many releases since 2023. It means the sample code is unlikely to reflect the current app, that Chromium and Playwright have both moved several major versions underneath it, and that you should budget an afternoon writing your own thin client rather than cloning theirs. Treat the repo as a protocol hint, not a dependency. The absence of a licence file on both is a second, separate reason not to paste their code into anything you ship.

By contrast, a vendor that writes minimum app versions directly into its API reference, as Nstbrowser does with 1.17.3+, 1.19.0+ and 1.22.4+, is giving you a maintenance signal you can act on without cloning anything.

Strip away the feature names and a local antidetect API is useful for exactly one reason: it hands back a Chrome DevTools Protocol address for a browser it launched with the fingerprint and proxy you configured. Everything else is profile bookkeeping you could do in the GUI.

Hidemyacc's Start Profile reference documents that field explicitly. The success response table lists port as a Number ("PORT auto") and wsUrl as a String, with the description "Used to integrate Puppeteer". Its own example response is worth reading closely, because it tells you what you are attaching to:

{
    "code": 1,
    "data": {
        "success": true,
        "port": 27999,
        "wsUrl": "ws://127.0.0.1:27999/devtools/browser/23b9ca53-5e90-4977-99a9-30a95b0c03f5",
        "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36",
        "majorVersion": 113
    }
}

The docs also note that in 3.0 "you can adjust proxy when starting profiles", with a proxy object and a params string for Chromium command-line switches. That matters for proxy hygiene: setting the exit at launch rather than editing the stored profile keeps credential rotation out of your profile database. The majorVersion field in their published example says 113, which is a documentation sample rather than a statement about what the current build ships, so do not read a Chromium version off it.

Once you have a wsUrl, the vendor stops being interesting and your code becomes portable. This is the whole integration, and it is the same shape at every vendor in row one of the taxonomy. Only the base URL changes.

# attach_over_cdp.py  -  launch a profile through a local antidetect API, then drive it.
#   pip install requests playwright  &&  python -m playwright install chromium
import sys
import requests
from playwright.sync_api import sync_playwright

LOCAL_API = "http://127.0.0.1:2268"      # Hidemyacc 3.0 local API, per its own docs
JSON_HEADERS = {"Content-Type": "application/json"}


def start_profile(profile_id, proxy=None):
    """POST /profiles/start/:profileID -> {"code": 1, "data": {"port": .., "wsUrl": ..}}"""
    body = {}
    if proxy:
        body["proxy"] = proxy                 # 3.0 lets you set the exit at launch
    r = requests.post(f"{LOCAL_API}/profiles/start/{profile_id}",
                      headers=JSON_HEADERS, json=body, timeout=180)
    if r.status_code == 402:
        sys.exit("402 from the local API: this plan cannot be scripted. Do not retry.")
    r.raise_for_status()
    data = (r.json() or {}).get("data") or {}
    ws = data.get("wsUrl")
    if not ws:
        sys.exit(f"no wsUrl in the response, so there is nothing to attach to: {data}")
    return ws


def stop_profile(profile_id):
    try:
        requests.post(f"{LOCAL_API}/profiles/stop/{profile_id}", timeout=60)
    except requests.RequestException:
        pass                                  # the run already produced its row


def read_one(profile_id, url, selector):
    ws = start_profile(profile_id)
    try:
        with sync_playwright() as p:
            browser = p.chromium.connect_over_cdp(ws)
            ctx = browser.contexts[0] if browser.contexts else browser.new_context()
            page = ctx.pages[0] if ctx.pages else ctx.new_page()
            page.goto(url, wait_until="domcontentloaded", timeout=45000)
            node = page.query_selector(selector)
            return node.inner_text().strip() if node else None
    finally:
        stop_profile(profile_id)


if __name__ == "__main__":
    print(read_one(sys.argv[1], "https://www.sparkproxy.io/", "h1"))

Two details in there are the difference between a script that runs for a month and one that wedges. The 402 branch exits instead of retrying, because a plan-level refusal will never succeed on attempt two and a retry loop against a billing error just burns your rate limit. And stop_profile swallows its exception inside a finally, because by the time you are closing the browser the row has already been written and a failed shutdown should not lose it. Whether to prefer Playwright or Selenium for the attach step is a genuine toss-up; Playwright versus Selenium compares them on the axes that matter once you are past the gate.

Before you pay any gate, there is a cheaper question: does this target actually need a fingerprinted browser? A surprising amount of work that gets built on antidetect profiles is reading server-rendered HTML through a residential exit, which needs a good IP and no browser at all. If a plain fetch returns the markers you are looking for, the correct scripting floor is zero and the whole comparison above is moot.

The SparkProxy Scraping API makes that a two-request experiment. The base is https://scrape.sparkproxy.io/api/v1, authenticated with an X-API-Key header, and new accounts get 1,000 free credits. The pricing is what makes the test worth running: render_js defaults to true and costs 5 credits, while render_js=false is a plain fetch at 1 credit. Adding country_code costs 5 more either way. So the cheap arm of the experiment is 6 credits and the expensive arm is 10.

Two parameter traps are worth stating plainly, because both have bitten real code. format controls content conversion only and takes html, md, mdx, json, screenshot or pdf; using format=json to mean "give me a response envelope" is a mistake that silently returns converted content instead. The envelope comes from json_response=true and nowhere else, and its body field is base64, so it must be decoded before you match a marker against it. Separately, extract_rules replaces the response with an extracted object, so never stack it with json_response.

# needs_a_browser.py  -  decide whether a target needs a rendered browser at all.
#   pip install requests
import base64
import json
import requests

API = "https://scrape.sparkproxy.io/api/v1"
KEY = "sk-replace-me"                       # sent as the X-API-Key header
MARKERS = ["data-sku", "add-to-cart", "itemprop"]


def fetch(url, render_js, country=None):
    """json_response=True is the only thing that returns the envelope, and the
    envelope's body field is base64, so decode it before matching anything."""
    body = {
        "url": url,
        "render_js": render_js,             # False = 1 credit, True = 5 credits
        "proxy_type": "premium",
        "json_response": True,
    }
    if country:
        body["country_code"] = country      # +5 credits
    r = requests.post(API,
                      headers={"X-API-Key": KEY,
                               "Content-Type": "application/json"},
                      json=body, timeout=180)
    r.raise_for_status()
    envelope = r.json()
    html = base64.b64decode(envelope["body"]).decode("utf-8", "replace")
    return envelope, html


def route(url, country=None):
    plain_env, plain_html = fetch(url, False, country)
    plain_hits = [m for m in MARKERS if m in plain_html]
    if len(plain_hits) == len(MARKERS):
        return {"route": "plain fetch, no browser needed",
                "credits": plain_env["credits_used"],
                "status": plain_env["status_code"]}

    rendered_env, rendered_html = fetch(url, True, country)
    rendered_hits = [m for m in MARKERS if m in rendered_html]
    if len(rendered_hits) > len(plain_hits):
        return {"route": "rendering earns its keep",
                "credits": plain_env["credits_used"] + rendered_env["credits_used"],
                "status": rendered_env["status_code"]}

    return {"route": "neither worked, so this is a blocking problem not a rendering one",
            "credits": plain_env["credits_used"] + rendered_env["credits_used"],
            "status": rendered_env["status_code"]}


if __name__ == "__main__":
    print(json.dumps(route("https://www.sparkproxy.io/", "de"), indent=2))

The third branch is the one people skip, and it saves the most money. If neither the plain fetch nor the rendered fetch returns your markers, rendering was never the problem and buying a more expensive browser tier will not fix it. You have a blocking problem, which is an IP and session problem. The honest comparison of those two routes is in web scraping API versus self-managed proxies.

Where the answer is "yes, it needs a real logged-in profile", which is most multi-account work, the proxy side is the other half of the bill and it does not scale with your browser tier. SparkProxy packs start from $75 a month with unlimited bandwidth, 1M+ premium IPs across 80+ countries, HTTP, HTTPS and SOCKS5, IP whitelist or user:pass auth, a 1 Gbps port, and random or 5-minute auto-rotation, plus a 24-hour free trial with no card. Term discounts run 5% at three months, 10% at six and 15% at twelve. Because the billing unit is the pack rather than traffic consumed, that line stays flat whether your browser subscription is $0 or $99, which is exactly why the next section can hold it constant. The pairing considerations are in proxies for antidetect browsers.

Same task, five bills. The job: 40 persistent profiles, each opening one URL, reading one element and appending a row, once a day for 30 days. Browser subscription only, with the proxy line held at the same figure on every row so the gate is the only variable.

# one_task.py  -  one scripted job, priced at each vendor's scripting floor.
#
# The job: 40 persistent profiles. Each opens one URL, reads one element, appends a
# row. Once a day, 30 days. Browser subscription only; the proxy line is held constant.

PROFILES_NEEDED = 40
DAYS = 30
PROXY_PLAN = 75.00          # SparkProxy entry pack, unlimited bandwidth, identical per row

FLOORS = [
    # vendor,        scripting tier,     $/mo,  profiles, launches/day, $/extra launch
    ("Nstbrowser",   "Standard (free)",   0.00,     500,           30,          0.01),
    ("GoLogin",      "Professional",      9.00,      10,         None,         None),
    ("Incogniton",   "Entrepreneur",     29.99,      50,         None,         None),
    ("Undetectable", "Base",             34.00,      50,         None,         None),
    ("Hidemyacc",    "Team",             99.00,     300,         None,         None),
]


def bill(price, profiles, cap, per_extra):
    """Monthly browser cost, plus whatever the daily launch cap adds."""
    if profiles < PROFILES_NEEDED:
        return None, f"only {profiles} profiles, the job needs {PROFILES_NEEDED}"
    if cap is None or PROFILES_NEEDED <= cap:
        return price, "fits"
    # A profile launched several times in one day still counts once, so the overage
    # is driven by distinct profiles touched per day, not by how often you run.
    over = (PROFILES_NEEDED - cap) * per_extra * DAYS
    return price + over, f"{PROFILES_NEEDED - cap} launches a day over the {cap} cap"


rows = []
for vendor, tier, price, profiles, cap, per_extra in FLOORS:
    total, note = bill(price, profiles, cap, per_extra)
    rows.append((vendor, tier, total, note))

priced = sorted([r for r in rows if r[2] is not None], key=lambda r: r[2])
blocked = [r for r in rows if r[2] is None]

print(f"{'vendor':<13}{'tier':<18}{'browser':>9}{'+proxy':>9}  note")
for vendor, tier, total, note in priced:
    print(f"{vendor:<13}{tier:<18}{total:>9.2f}{total + PROXY_PLAN:>9.2f}  {note}")
for vendor, tier, _total, note in blocked:
    print(f"{vendor:<13}{tier:<18}{'n/a':>9}{'n/a':>9}  {note}")

low, high = priced[0][2], priced[-1][2]
spread = "n/a" if low == 0 else f"{high / low:.0f}x"
print(f"\nbrowser line: ${low:.2f} to ${high:.2f} a month, a {spread} spread")
print(f"proxy line:   ${PROXY_PLAN:.2f} on every row, so the gate is the only variable")

Output:

vendor       tier                browser   +proxy  note
Nstbrowser   Standard (free)        3.00    78.00  10 launches a day over the 30 cap
Incogniton   Entrepreneur          29.99   104.99  fits
Undetectable Base                  34.00   109.00  fits
Hidemyacc    Team                  99.00   174.00  fits
GoLogin      Professional            n/a      n/a  only 10 profiles, the job needs 40

browser line: $3.00 to $99.00 a month, a 33x spread
proxy line:   $75.00 on every row, so the gate is the only variable

Four things in that output are worth more than the ranking.

Nstbrowser's free plan wins at $3 a month, and the $3 is overage rather than subscription: 10 profiles a day past the 30-launch cap at $0.01, times 30 days. Because the cap counts distinct profiles rather than runs, raising the job from once a day to ten times a day leaves that $3 unchanged. That is a genuinely different billing shape from everyone else here, and it rewards workflows that touch few profiles often rather than many profiles once.

GoLogin drops out entirely, which is the most useful result in the table. Its $9 scripting floor is real, but it covers 10 profiles, and the 50-profile variant has no published price. A floor you cannot actually sit on is not a floor, and this is why ranking on the API price alone without checking the allowance attached to it produces a shopping list you cannot buy.

Hidemyacc's own ladder shows the gate biting rather than the capacity. Base at $49 holds 100 profiles, comfortably more than the 40 this job needs, and cannot run it. Starter at $29 holds 30, which is too few anyway. So the binding constraint is not profile count, it is the API row, and you cross from $29 to $99 to get it.

And the proxy column is flat at $75 on every row. Over 30 days the browser line moves by $96 while the proxy line does not move at all, which means the gate is the only decision in this comparison that changes your bill. If you are sizing the proxy side independently, concurrency rather than inventory is the number to size on.

Three caveats on that arithmetic, because precision matters more than a clean table. Incogniton's $29.99 is its month-to-month figure and drops to $20.99 a month on six-month billing, which would put it below Undetectable. Nstbrowser's overage rate came from the Standard column of its pay-per-use table and its own paid Starter tier prints a higher one, so confirm it on your invoice. And none of these rows include the cost of the hours you spend writing a client against a stale examples repository.