Back to Blog

How to protect free minutes on a headless browser API

Every new account is a new set of free browser minutes. What headless browser API free tier abuse costs, which basic fixes break and how to guard paid capacity.

Start with one minute of one headless browser, then keep adding what it takes to give that minute away.

Compute, 1 vCPU and 2 GB         $0.0010
Idle pool, 40% busy (x 2.5)      $0.0025
Bandwidth, 10 MB (+ $0.0010)     $0.0035
Recordings, 30 days (+ $0.0005)  $0.0040
1,000 free minutes (x 1,000)     $4.00 a month
30 accounts, one person (x 30)   $120 a month
12 people doing that (x 12)      $1,440 a month
A year of it (x 12)              $17,280

This is a scenario, and every input is an assumption you should replace: compute at $0.06 an hour, bandwidth at $0.10 per GB, a free plan of 1,000 minutes. That sum is headless browser API free tier abuse on a quiet day. It's 360 accounts (12 × 30), each with a verified email and a working API key, and each one inside the limits you set.

The bill is the gentle part, because a browser minute also occupies a slot. Say your free minutes reset at midnight UTC on the 1st, each free account can run 2 browsers at once, and those 12 people each have a job waiting for the reset.

  • 360 accounts × 2 browsers = 720 browsers wanted at 12:01 a.m.
  • Your fleet is capped at 600, and paying customers are using 300
  • 720 - 300 = 420 sessions left waiting
  • Sessions last about 5 minutes, so 600 ÷ 5 = 120 slots open each minute
  • 420 ÷ 120 = a 3.5 minute wait for any new session
  • Your customers' connection timeout is 30 seconds

A paying developer's new session joins the back of that line and gives up 3 minutes before reaching the front. And the line stays. Those accounts hold 360,000 minutes between them, and with 300 slots to spend them on, that's 1,200 minutes, or 20 hours.

Browsers wanted on the 1st, illustrative02004006008001000120004812162024BrowsersHours after midnight UTC
Browsers wanted on the 1st, illustrative0500100004812162024BrowsersHours after midnight UTC

The bars are browsers wanted. The line is your cap.

At 7:40 a.m. UTC a customer on your $99 plan writes in. They render invoice PDFs through your API, and the 1st is the one day that job can't slip. "Every render has timed out since midnight. 2,300 invoices should've gone out by now. Are you down?" Your status page is green, and it's telling the truth. All 600 browsers are healthy. Most of them are running free jobs.

Say you have 150 customers at $99, so $14,850 a month, and 40 of them were hit. You refund each of them a month, which is 40 × $99 = $3,960. To stop this happening on the next 1st, you raise the cap. The timeouts stop, and now your peak chart says 1,020 browsers. Holding headroom for that hour means paying for it, so say you commit to 100 more slots for a year at a discounted $0.04 an hour:

  • 100 × $0.04 × 730 hours = $2,920 a month
  • $2,920 × 12 = $35,040 over the year
  • First month: $1,440 + $3,960 + $2,920 = $8,320, or 56% of that month's revenue

The costs outlast the signups. Those 360 accounts can go quiet tomorrow and the commitment still runs for 12 months. Their recordings sit in storage until retention ends. Their jobs left through the same outbound IP addresses your paying customers use, so if a site started refusing those addresses, a paying customer's page comes back blocked weeks after the free account has gone. The invoice customer took the refund, and also put a second provider behind a config flag.

On the 2nd you choose: keep paying for capacity that serves 12 people who were never going to buy, or cut the free tier that brought you most of those 150 customers.

Why free browser minutes get multiplied

Everything you meter on a browser API hangs off the API key: minutes, concurrent sessions, session length. One new key is one new set of all three, and moving a job onto it means changing an environment variable. Your users automate things for a living. Most API products share this problem, but a browser makes it worse. A session is heavy enough that you pay by the minute instead of by the request, and what comes out of it is finished work: a scraped page, a PDF, a screenshot. Once someone has the file, nothing keeps them on your product.

The obvious fix is to cut free concurrency from 2 to 1. Free demand drops from 720 browsers to 360. But 360 + 300 is still 60 over your cap, and 60 ÷ 120 is a 30-second wait, right on the timeout. The bill doesn't move at all, because it's the same 360,000 minutes at $0.004. Meanwhile the honest developer who came to test your API in parallel no longer can.

Protect paying capacity first

Do these first. They work no matter who holds the free accounts.

Give free sessions their own pool. Cap it at 100 browsers and a free wave can only fill those 100. The same 360,000 minutes would now take 60 hours, and the only people waiting are on the free plan.

Spread out the resets. Refresh each account's minutes on its signup date, so the 1st stops being a wall of demand. It costs nothing.

Give the free pool a monthly budget. At $0.004 a minute, $500 buys 125,000 minutes. When it's spent, free sessions get a clear error and an upgrade link.

Shrink what a free session keeps. One day of recordings instead of 30, and a 5-minute session limit.

Plan capacity from paid peaks only. Chart paid and free separately, and never sign a commitment off the combined number.

YesNoNoYesYesNoPaid API key?Paid pool,first in lineFree budget left?Refuse with anupgrade linkFree pool slot open?Run with a5 minute limitWait briefly,then refuse
YesNoNoYesYesNoPaid API key?Paid pool,first in lineFree budget left?Refuse with anupgrade linkFree pool slot open?Run with a5 minute limitWait briefly,then refuse

These limit the damage, but they treat every free account the same. With 100 browsers running, 12 people can spend that whole $500 budget in under a day (125,000 ÷ 100 = 1,250 minutes), and then a real developer trying your API for the first time gets the refusal. So you also go after the extra accounts.

The basic fixes for extra accounts, and how they break

Basic fixWhat it catchesWhat it missesWho it wrongly blocksUpkeep
Email verificationTypos and dead inboxesAny real inboxAlmost nobodyDelivery problems
Unique emailsExact repeatsEvery new addressAlmost nobodyVery little
Disposable-domain blockKnown throwaway domainsNew ones, and domains people ownPrivacy-minded developersA list someone updates for good
Gmail dots and plus tags as one addressEasy repeats, since Gmail ignores dots and plus-tagged mail reaches the same inboxAny second mailboxPeople who sort their mail with plus addressesAnother rule to keep correct
Signup CAPTCHABasic signup scriptsA person creating accounts by handScreen-reader usersLost signups, every day
Phone verificationCasual repeatsRented numbersDevelopers you can't text, or who won't share a number to test an APIA fee on every text
Card on fileMany casual repeatsVirtual and prepaid cardsDevelopers without a company cardFewer signups
One account per IPRepeats from one connectionAnyone with a second connectionOffices, campuses and coworking spacesSupport tickets
VPN blockKnown VPN rangesAnyone not on oneDevelopers on a company VPNA list that goes stale
Rate limitsA runaway loop on one key360 keys, each inside the limitBursty test suitesTuning
Usage capsOne account overspendingNew accounts, since the cap is what gets multipliedProjects that outgrow freeVery little
Minutes that expire soonerDormant costA new account gets a new clockSlow evaluatorsVery little
Manual reviewPatterns you happen to spotAlmost everything: 360 accounts × 2 minutes is 12 hours a monthAnyone who looks odd that dayYour time

Look at the effort on the other side. Thirty accounts at 2 minutes each is one hour of someone's afternoon, and it buys 30,000 free minutes every month after that. What you really want to know is whether this developer already had their minutes under another key, and your tables can only answer that about an account.

A card on file is the strongest basic here, and if your free tier costs real money it deserves a serious look. It also turns away the developer trying your API on a Sunday, the one with no company card who might have brought the $99 plan to work on Monday. They won't file a ticket. They'll try the next API on the list.

You end up maintaining a domain list and a review queue beside the browser fleet you set out to build.

Evaluate the claim before the minutes go out

You don't have to build your own abuse prevention system, or staff that table. AbuseZero is an API for one moment: free minutes are about to go out, and your server asks whether this claim should go through. One call, and you get a clear allow or deny under rules you control.

Go back through what broke. Where the domain list and alias rules ran out, AbuseZero checks mailbox aliases, disposable domains and mail routing. Where one-per-IP punished coworking spaces, it sees beyond an IP address with VPN, hosting, network reputation, Tor and proxy intelligence. A card requirement only learns that a card works, while AbuseZero detects repeated payment fingerprints across users, even when new accounts and emails hide the connection. It recognizes repeat devices across new accounts, even when email addresses keep changing. It blocks spammy bots, browser automation and malicious scripts while allowing genuine AI agents and assistants. It puts 140,000+ signals through multi-layer AI risk analysis, which detects linked claims and flags abuse that single checks miss, and no table of rules gets near that. The algorithm is proprietary, with AI that checks the claim again. Creating a fresh account isn't enough to erase previous activity.

Run an evaluation when a new account asks for its free API key, and again when its monthly minutes come back. Eligibility can be once per user or once per calendar month. Observe mode shows what would be denied before anyone is blocked, and the quickstart covers your first benefit. Your API still meters the minutes.

Frequently asked questions

Is heavy use of one free account abuse?

No. A developer with a big test suite can burn 1,000 minutes in an afternoon, and that's what the free plan is for. The problem is one person collecting more free minutes than you meant to give one developer.

Should free accounts get more than one concurrent session?

Usually, if parallel runs are what people come to test. Keep a low limit and let the free pool protect everyone else. Then set free plan limits that don't invite extra accounts.

Should I remove the free tier?

Developers want to try an API before they pay for it, so removing your free tier is a last resort.

Keep your browser fleet for the people paying for it

Keep reading

Copying your prompt…

Copied the to your clipboard. Give it to your coding agent & it will handle the rest.