SparkProxy vs Evomi: What the Cheapest Plan Buys

Start with the smallest amount of money that gets you a working proxy at each vendor. Not the advertised per-gigabyte rate, the actual transaction.

Sources: evomi.com/pricing, evomi.com/buy-proxies, evomi.com/datacenter-proxies, evomi.com/static-residential-proxies, evomi.com/scraper-api, all read 2026-10-09.

Evomi's floor is genuinely low, and for a team with a $20 budget that matters more than any per-gigabyte comparison. Forty-five cents buys a working datacenter gigabyte that never expires. SparkProxy has nothing at that price and doesn't pretend to; the entry pack is $75 a month.

But "the cheapest purchase" and "the cheapest purchase that does my job" are two different numbers at Evomi, and the gap between them is sometimes eight-fold. That gap is what the rest of this page is about. If you're sizing a first proxy budget from scratch, our notes on proxy budget planning for small teams, how much proxies cost and the roundup of cheap proxy providers cover the general shape of the problem.

Evomi doesn't have one entry price. It has seven product lines, each with its own unit and its own bottom rung. The $0.49/GB headline belongs to exactly one of them.

Core Residential. The default rotating pool and the source of the headline. Pay as you go is $0.99/GB from 15 GB, falling to $0.79/GB from 1,000 GB. The monthly plan is 100 GB for $49, which Evomi states as $0.49/GB, with extra gigabytes at the same $0.49. Evomi's published pool claim is "54M+ ethically sourced residential IPs" across "150+ countries", which is the vendor's own figure and not independently auditable. Our explainer on proxy pool size claims covers why those numbers rarely compare across vendors.

Premium Residential. A separate, curated pool: $3.98/GB pay as you go, priced from 1 GB with no minimum stated ("No commitment, and the data you buy does not expire"), Flex at $30/month for 8 GB ($3.75/GB), Pro at $90 for 25 GB ($3.60/GB), Advanced at $170 for 50 GB ($3.40/GB). Evomi says it falls "as low as $2.20/GB" on its largest monthly plans, which are quote-only. Nothing between the $170 Advanced plan and that rate is published. The difference between the two residential pools is worth understanding before you pick one; see premium vs standard residential pools.

Mobile. The only fully published ladder on the site, bottom to top: $3.98/GB pay as you go priced from 1 GB, Flex $30 for 8 GB, Pro $90 for 25 GB, Advanced $170 for 50 GB, Performance $320 for 100 GB, Business $750 for 250 GB, Scale $1,400 for 500 GB, Max $2,600 for 1,000 GB, Enterprise $11,000 for 5,000 GB, which works out at $2.20/GB. Evomi's mobile page claims "3M+ genuine carrier IPs across 150+ countries", targetable by country, region, city, continent and carrier, with the carrier key written as isp-, for example isp-tmobileusainc.

Datacenter. $0.45/GB pay as you go priced from 1 GB, Basic $80/month for 200 GB ($0.40/GB), Standard $175 for 500 GB ($0.35/GB), Advanced $300 for 1,000 GB ($0.30/GB). Plans from 200 GB include a dedicated account manager. This is a rotating shared pool only; Evomi's own FAQ states that its "rotating, traffic-priced datacenter product does not sell dedicated or private IP allocations". Geo-targeting here is country and ISP only.

Static Residential (ISP). Billed per IP per month with unlimited bandwidth and no data meter: Shared from $1.00 per IP, Private from $2.50, Virgin from $4.50. Subscription only, no pay as you go, and Evomi's buying guide states there's "No volume tier" on this product. The cards read "Starting from" and carry a location selector (for example "Ashburn, ATT"), so those three numbers are entry rates for some locations rather than a price list, and no minimum IP count is published. Don't assume you can buy exactly one address for a dollar. For the general model, see ISP proxy pricing per IP and what ISP proxies are.

Scraper API. Billed per 1,000 successful results: $0.20/1K pay as you go, Developer $44.99/month at $0.16/1K with 275,000 credits and max concurrency 25, Startup $149.99 at $0.14/1K with 1,050,000 credits and concurrency 55, Business $379.99 at $0.13/1K with 2,925,000 credits and concurrency 105.

There's a wrinkle in that last line worth doing the division on. Evomi's docs price a result in credits: request mode with a datacenter proxy is 1 credit, request mode with residential is 2, browser mode with residential is a flat 5, and auto mode with residential is 2 credits if the plain request succeeds or 6 if it upgrades to a browser. Screenshot adds 1 and AI Enhancement adds 10, both additive. Now divide the plan: $44.99 over 275,000 credits is $0.1636 per thousand credits, which is exactly the published "$0.16/1K". So the quoted rate tracks credits, not results, and a result costs 1 to 6 credits. On the Developer plan that makes a residential request-mode result about $0.33 per thousand and a browser-mode result about $0.82 per thousand, by our arithmetic. Evomi's page says "per 1,000 successful results" and its credit table says a result costs up to six credits; the two statements aren't reconciled anywhere on the site, so treat the headline as a floor and check your own credit burn. If you're comparing credit systems generally, scraping API credit pricing breaks down how the units differ.

Scraping Browser. A managed Puppeteer and Playwright cloud browser: Prototyping $24.99/month for 60,000 credits ($0.20 per browser hour, 125 hours), Growth $129.99 for 350,000 credits ($0.18/hour, 729 hours), Scale $249.99 for 750,000 credits ($0.16/hour, 1,562 hours). About 480 credits per browser hour on every plan. Overage runs $0.00075, $0.0005 and $0.0004 per credit in plan order. Subscription only.

Against all seven: SparkProxy sells one shape, and the shape is datacenter. Rotating datacenter packs start at $75/month with unlimited bandwidth across two pools, "USA Rotating" (50,000+ premium US datacenter IPs) and "Worldwide Rotating" (1M+ datacenter IPs across 80+ countries), with HTTP, HTTPS and SOCKS5, random rotation and 5-minute auto-rotation, 1 Gbps port speed, IP whitelist and user:pass auth, and a 24-hour free trial with no card. Larger packs add concurrency rather than gigabytes. There is no SparkProxy residential, mobile or static ISP product, which is the most consequential fact on this page: it means six of Evomi's seven lines have no SparkProxy counterpart at any price. The Scraping API lives at https://scrape.sparkproxy.io/api/v1 with an X-API-Key header and 1,000 free credits on signup.

On performance, Evomi's residential docs publish "Average response times of <0.5s" and a "99.95% connection success rate" (docs.evomi.com/proxy-instructions/residential-proxies/, read 2026-10-09), and its residential product page cites a July 2026 Proxyway benchmark reporting 99.98% success in the US and UK. Those are Evomi's own claims and a third party's claim relayed by Evomi. We went looking for a published uptime SLA on an Evomi-owned page and didn't find one, so there's no SLA figure here either. We haven't run a head-to-head between the two networks, so there is no success-rate, latency or block-rate figure anywhere in this post.

This is the plan the $0.49 headline describes, so it's worth being exact about its contents.

A few of those deserve a sentence each.

Asking for a sticky lifetime above the 1440-minute maximum returns HTTP 412, which is a clean failure mode and better than silently clamping. Sessions themselves cost nothing extra, which is not true at every vendor; see sticky session proxies for why that matters on login-bound work.

Targeting depth differs by product, and Evomi's FAQ spells it out: "Residential proxies can be targeted by Country, Region, Continent, ASN, ISP and City. Mobile proxies support Country, Region, City and carrier. Datacenter proxies support Country and ISP." So the cheap datacenter gigabyte doesn't do city-level targeting; only residential and mobile do.

There's one conflict on Evomi's own site we can't resolve for you. The Static Residential product page lists "HTTP, SOCKS5 and UDP" and says you can "Access your ISP proxy using UDP, HTTP or SOCKS5". Evomi's connection docs for that same product list only HTTP on port 12345 and SOCKS5 on port 12346. The general FAQ says "Only TCP is supported". And UDP appears separately as an Enterprise-only, manually activated Core Residential expert flag, _udp-1. If your application needs UDP, get that answer in writing before you buy.

And the one with the most operational weight: no IP whitelist. Evomi's FAQ is unambiguous. "Currently, we do not support IP authentication. However, we are considering implementing this feature in the future. At present, we only offer username and password authentication for secure access." The datacenter page repeats it: "IP whitelisting is not supported." More on what that costs you in day one.

Here's a line nobody puts on a pricing page. Evomi sells the same Core Residential pool two ways, at $0.49/GB on the $49 monthly plan and at $0.99/GB pay as you go. The subscription looks like half price. Divide, though:

$49 / $0.99 = 49.49 GB.

So 49 GB bought pay as you go costs $48.51, which is less than the $49 subscription. At 50 GB, pay as you go costs $49.50 and the subscription finally wins. The headline rate of $0.49/GB describes a customer who uses all 100 GB every month. A customer who uses 40 GB is paying $1.23/GB on the plan that advertises $0.49.

Unused subscription bandwidth doesn't carry over. Evomi's FAQ: "For subscription plans, unused bandwidth does not roll over to the next month. However, with our pay-as-you-go plans, there is no time limit." Extra data bought mid-cycle is billed at the subscription rate and is usable only until the next renewal date.

Run that over a lumpy quarter. Say you use 80 GB in month one, 5 GB in month two, 40 GB in month three, 125 GB in total.

Pay as you go is $23.25 cheaper across the quarter at double the advertised rate, because the subscription charges for headroom you don't use. The only catch is the 15 GB minimum purchase, so your first top-up is $14.85 whether you need 2 GB or 15.

This is the single most useful thing a small-budget reader can take from Evomi's price list, and it points the opposite way from the marketing. Under roughly 50 GB a month, buy the dearer unit. Our guide to forecasting proxy bandwidth needs and the comparison of monthly vs annual plans both apply here.

Now map jobs onto products. The question isn't what the cheapest gigabyte costs, it's what the cheapest gigabyte that does your job costs.

Three readings of that table.

First, the jump from Core to Premium is $0.49 to $3.75, which is 7.7x. If your job needs sub-pool selection, ISP targeting on residential, or the built-in ad blocker, your floor was never $0.49/GB. It's $3.75/GB, and the cheapest monthly ticket to it is $30 for 8 GB. At that rate $75 of Premium traffic is 20 GB, and since Flex caps at 8 GB the real routes to 20 GB of Premium are pay as you go at $3.98/GB ($79.60) or the $90 Pro plan. That's a budget observation rather than a recommendation: if your job needs the Premium pool, a datacenter pack at any price doesn't do it, and the $30 floor you were planning for is really $90.

Second, several things you'd reach for on a hard target are filters rather than products, which means they don't change your plan, they change your bill. More on that next.

Third, the bottom row isn't a price, it's an absence. No amount of money buys IP whitelist authentication at Evomi today.

Evomi documents a set of Core Residential "expert settings" that select exits far more precisely than geography does. The docs are explicit about what they cost: "Each expert parameter adds a multiplier to your bandwidth usage: Per-parameter multipliers: Added cumulatively. Maximum cap: 15x total multiplier. Total Bandwidth Deducted = Actual Bandwidth x (Sum of Multipliers)". The worked examples on that page show one parameter at 4x costing 4 MB for every 1 MB transferred, and five parameters summing to 20x being capped at 15x.

Source: Evomi expert settings docs, read 2026-10-09. Evomi notes these are "only available for Core Residential Proxies".

What the docs never publish is which filter costs which multiplier. The mechanism is documented, the cap is documented, illustrative values of 2x, 3x and 4x appear in examples, but no table maps a filter to a number. The docs say "Dashboard shows actual vs. multiplied usage breakdown" and that "Enterprise customers may receive customized multiplier values". So we won't tell you what _asn- costs, because Evomi doesn't. Turn the filter on during the trial and read the dashboard.

To Evomi's credit, it says this itself on its own comparison page, where the footnote notes that its ASN, TCP/IP, fraud-score and response-time filters "are expert settings and can increase your cost". That's more candour than most vendors manage about their own price list.

Now the arithmetic that matters. Read it as a budget comparison, not a swap: expert filters are a Core Residential feature and SparkProxy sells no residential product, so what follows prices how much real traffic $75 buys on each side rather than offering one as a substitute for the other. SparkProxy's $75 pack equals $75 / $0.49 = 153.06 billed gigabytes on Evomi's monthly plan. Billed gigabytes are actual transfer multiplied by the filter multiplier, so:

Our arithmetic, from Evomi's published $49 plan plus $0.49 per extra gigabyte: 153 GB bills as $49 + (53 x $0.49) = $74.97, and 154 GB bills as $75.46.

Read the right-hand column. At the documented cap, roughly ten gigabytes of real transfer costs the same as an unmetered month. You will probably never sit at 15x, but you only need two or three filters to be somewhere in the middle of that table, and the point is that the per-gigabyte rate you were quoted stops describing your bill as soon as the job gets specific. If ASN selection is central to your work, ASN-targeted proxies covers the technique, and validating IP geolocation accuracy and fraud scores covers what a fraud-score filter can and can't tell you.

The second thing that moves a metered bill is the minimum. Evomi's Terms of Service state that "all requests routed through our network carry a minimum data threshold of 512 bytes... A minimum deduction of 512 bytes will be applied to your account balance for every such request." Its docs price that at "approximately $0.00000025088 per request" at $0.49/GB (docs.evomi.com/proxy-instructions/residential-proxies/, read 2026-10-09).

Work backwards from Evomi's own figure: $0.00000025088 / $0.49 = 5.12 x 10^-7 GB, which equals 512 bytes only if a gigabyte is 1,000,000,000 bytes. So the meter is decimal, and one gigabyte is 1,953,125 minimum-size requests.

Where the floor bites:

• A JSON poller doing 10 million requests a month at about 300 bytes a response transfers 3.0 GB but bills 5.12 GB, a 71% premium. In money that's $2.51 against $1.47, which is small.
• Redirect chains multiply it. Three 302 hops plus the real page is four billed requests, three of them at the floor.
• Health checks, HEAD probes and preflight requests all bill at the floor.
• Evomi's proxy products meter bytes transferred, so a 403 block page bills for the bytes it moved. That's our inference from the metering model plus the 512-byte clause rather than a published Evomi billing statement; Evomi's no-charge-on-failure guarantee is published for the Scraper API only.

Be honest about magnitude: on its own the 512-byte floor is a rounding error for most workloads. It matters for two reasons. It's a second place where "a gigabyte" isn't the gigabyte you measured, and it stacks with whatever filter multiplier you're running. Evomi's docs don't say whether the multiplier is applied before or after the 512-byte floor, so we won't guess; ask support and get it in writing if your traffic is request-dense.

# Billed vs actual bytes under a 512-byte-per-request minimum.
# Feed it your own access log sizes, one response size in bytes per line.
import sys

FLOOR = 512
GB = 1_000_000_000          # Evomi's own per-request figure implies decimal GB
RATE = 0.49                 # USD/GB, Evomi Core Residential monthly, 2026-10-09
MULTIPLIER = 1.0            # raise this if you run expert filters

actual = billed = n = 0
for line in sys.stdin:
    line = line.strip()
    if not line.isdigit():
        continue
    size = int(line)
    actual += size
    billed += max(size, FLOOR)
    n += 1

billed *= MULTIPLIER
overhead = (billed / actual - 1) * 100 if actual else 0.0
print(f"requests      {n:,}")
print(f"actual        {actual/GB:.3f} GB  ${actual/GB*RATE:.2f}")
print(f"billed        {billed/GB:.3f} GB  ${billed/GB*RATE:.2f}")
print(f"overhead      {overhead:.1f}%")

Every crossover below is SparkProxy's $75 entry pack divided by an Evomi published rate. Our arithmetic, their numbers, 9 October 2026. The section is split in two because only half of it is a fair swap.

Like for like: datacenter against datacenter. Both vendors sell rotating datacenter traffic, so these rows compare two ways of buying the same class of address.

Read the first row as the real one. $0.45/GB is the only datacenter rate you can buy at any volume, and it crosses $75 at 166.7 GB a month. The three cheaper rates are plan rates, and every one of those plans costs more than $75 before you move a byte: Basic $80, Standard $175, Advanced $300. So at 187 GB you aren't choosing between $75 and $75, you're choosing between a $75 flat pack and an $80 commitment. Under roughly 167 GB of datacenter traffic a month Evomi's meter is cheaper and we'd buy it. Above that the flat pack is cheaper, and if your volume is high enough to reach the $0.30 rate you're comparing $75 flat against a $300 plan.

Budget against budget: the rest of the catalogue. These rows are not swaps, and reading them as swaps is the mistake this section exists to prevent. Evomi is the only one of the two vendors that sells rotating residential, mobile or static ISP addresses. If your target refuses datacenter ASNs, Evomi is your only option of the two and the flat pack isn't available to you at any price. What the table prices is how far a fixed $75 goes on each side, which is a real question for a small budget but a different question from which product to buy.

One caveat on reading both tables: those are rate divisions, and some of the rates sit on plans whose ceiling is lower than the volume shown. You can't buy 20 GB at the Premium Flex rate, because Flex is 8 GB; the routes to 20 GB of Premium are pay as you go at $3.98/GB ($79.60) or the $90 Pro plan. Where a plan ceiling intervenes, the practical crossover is lower than the division suggests, never higher.

Below those lines Evomi is cheaper, and we're not going to pretend otherwise. A team pushing 60 GB of plain residential traffic a month should buy Evomi, and not only on price: the $49 plan covers the volume outright against a $75 pack, and the $75 pack doesn't sell residential exits at all. The flat pack answers a datacenter workload and a billing-unit problem. It is not a cheaper route to household IPs, and we'd rather say that than win a comparison on a technicality.

Above those lines the flat pack is cheaper, and there's a second thing it buys that doesn't show up as a rate. On a metered plan, a page-weight regression after a target's redesign, a retry storm from a bad selector, a redirect loop, or a filter you switched on to make the job work all land on the invoice. On a flat pack they land in your bug tracker instead. The multiplier and the 512-byte floor both move the crossover down and neither moves it up, so the metered side of this comparison has one-directional risk. The broader argument is in per-IP vs per-GB proxy pricing, residential proxy pricing explained and whether unlimited bandwidth is worth it.

One more asymmetry. Because subscription gigabytes expire at renewal, a metered plan sized for your peak month is paid for twelve times a year and used once. A flat pack sized for your peak month is also paid twelve times, but every other month is free headroom rather than forfeited allowance.

Two things will hit you in the first hour with Evomi, and neither appears on a pricing page.

The credential travels. With no IP whitelist option, username and password is the only authentication method, and Evomi puts the targeting keys in the password field as well. So the secret lands in every container image, every CI runner, every scheduled box and every developer laptop, and the secret also encodes geography, which means a geo change is a config change everywhere. Rotating a leaked credential means touching all of it at once. Sub-user hygiene and short-lived credentials matter much more here than they do on a whitelisted gateway. SparkProxy supports both IP whitelist and user:pass across HTTP, HTTPS and SOCKS5, so a fixed-egress worker can authenticate with no secret on the box at all; see IP whitelisting for proxies.

# SparkProxy, whitelisted egress: no credential in the image.
curl -s -x http://gateway.sparkproxy.io:11000 https://www.sparkproxy.io/ -o /dev/null -w '%{http_code}\n'

# Same gateway with user:pass, for hosts whose egress IP isn't fixed.
curl -s -x http://USER:PASS@gateway.sparkproxy.io:11000 https://www.sparkproxy.io/ -o /dev/null -w '%{http_code}\n'

The verification you must not script. Evomi's Terms of Service contain a "Network Mapping" clause that prohibits requests to IP checker sites or IP reflection endpoints "for the primary purpose of logging, collecting, or identifying the IP addresses assigned to you". If detected, the stated consequence is that "your account will be terminated" and "all remaining bandwidth, credits, and subscription fees are forfeited, and no refunds will be issued".

Writing a loop against a what-is-my-IP service is the first thing most engineers do with a new proxy. Read that clause before you write it. Count distinct exits from your own logging endpoint or from the target's own response instead, and if your QA process genuinely requires IP enumeration, ask Evomi in writing what's permitted. Our walkthroughs on testing whether a proxy is working and proxy rotation intervals cover ways to verify rotation that don't depend on a third-party echo service.

Three more terms from the same document, since they're cheaper to read than to discover: resale or sublicensing requires prior written consent, a CHF 20.00 administrative fee applies per chargeback instance, and Evomi reserves the right to unilaterally adjust auto-recharge top-up amounts if that mechanism triggers more than five times in a month. Evomi's FAQ puts the reseller minimum at "typically... 5TB of data". Acceptable use policies are the most under-read document in this category.

The floor includes how much it costs to find out whether the thing works.

Evomi's buying guide states: "Choose a plan and confirm billing details to begin its free trial. Payment details are required." Trial length is given as "One day on Core Residential (1 Day Trial Available), and three days on most other eligible plans", and "The plan renews at its original price unless you cancel during the trial." Separately, the Terms of Service define the allowance as bandwidth: "We offer a one-time free trial for 100MB of traffic. You are not allowed to request this trial more than once."

Those two statements are not reconciled anywhere on Evomi's site. One is a time window, the other a byte budget. Plan your evaluation against whichever is stricter, which in practice means 100 MB.

The refund is narrower than "30-day money-back guarantee" sounds. It applies to a first purchase in a product category only, within 30 calendar days, once per category, and only if you've used less than "1 GB of bandwidth; or 10% of the purchased Bundle or Package", whichever comes first. Non-refundable third-party payment processing fees of up to 10% of purchase value may be deducted from what you get back.

And a list of things that are never refundable, per Evomi's refund policy: Static Residential (ISP) proxies, which are "treated as consumed upon delivery"; balance and credit top-ups; pay-as-you-go traffic; expired packages; any purchase preceded by a free trial of that product; and all reseller payments. Refunds also can't be returned to cryptocurrency, WeChat Pay, AliPay, SBP or Mollie-based payments.

Put the pieces together and one consequence falls out that nobody mentions. Pay as you go is the right floor under 50 GB a month, and pay as you go is explicitly non-refundable. Taking the trial on a product also voids the refund on that product. So the cheapest way in is also the least reversible way in, and your real evaluation budget is the 100 MB trial allowance. Size the test accordingly. We compare the category's practices in proxy free trials and refund policies, and how to run a proxy provider trial is the checklist we'd use with 100 MB.

Not hedging. These are purchases where we'd tell you to spend the money there. The first one is the largest and it isn't close.

1. Any job that needs a residential exit IP. Evomi sells a rotating residential pool it describes as "54M+ ethically sourced residential IPs" across "150+ countries", from $0.49/GB on the $49 plan, plus a curated Premium pool above it. SparkProxy's published lineup is datacenter only. Against a target that rejects datacenter ASNs on sight, Evomi isn't merely the cheaper option, it's the only one of the two that sells the product, and unlimited bandwidth on the wrong class of address is worth nothing. Test acceptance before you test cost; residential vs datacenter proxies covers how to tell which class a target actually demands.
2. Small and occasional jobs. Datacenter, mobile and Premium Residential start at 1 GB pay as you go, Core Residential at 15 GB (about $14.85), and purchased traffic never expires. If your whole month is a few gigabytes, or the work is seasonal and bursty, a $75 floor is more than the job needs.
3. Predictable residential volume under about 150 GB a month. The 100 GB Core Residential plan is $49 against a $75 entry pack. If 100 GB genuinely covers you and you don't need headroom, that's $26 a month saved, on a product we don't sell at all.
4. Per-IP static ISP work. Account management, long logged-in sessions, ad verification from one fixed vantage point, rank tracking that has to come from the same address every run. Shared static ISP IPs start at $1.00 per IP per month, Private at $2.50, Virgin at $4.50, all unmetered. SparkProxy's published lineup has no per-IP static ISP product, so Evomi isn't just cheaper here, it's the only one of the two that sells the thing.
5. Mobile and carrier targets. A published 3G/4G/5G pool (Evomi's claim: "3M+ genuine carrier IPs across 150+ countries") with carrier-level targeting and a fully published ladder from $3.98/GB down to $2.20/GB at 5,000 GB. SparkProxy has no mobile product. If your target only trusts a carrier address, Evomi wins outright; see carrier-targeted mobile proxies and what a mobile proxy is.
6. Fine-grained exit selection. Fraud score, maximum latency, device family, minimum connection age, ISP, ASN, postal code and HTTP/3 over QUIC are real controls, and SparkProxy publishes no equivalent. They cost multiplied bandwidth, which is the honest caveat, but if your job needs an exact ASN or a fraud-score ceiling then Evomi is the better tool.
7. Country breadth and city precision. 150+ countries claimed, with free country, region and city targeting on every plan, against SparkProxy's published 80+ countries. For localisation QA or geo-pricing work in long-tail markets, Evomi is likelier to have the exit you need.
8. Cheap bulk datacenter traffic. $0.30/GB on the 1,000 GB plan at $300/month, or $0.45/GB pay as you go from 1 GB, against targets that don't care who owns the address. For corpus collection and high-volume crawls of unprotected pages that's a lower cost per gigabyte than residential rates anywhere.
9. A managed Scraping Browser. A hosted Puppeteer and Playwright cloud browser from $24.99/month with the proxy network already wired in, billed at about 480 credits per browser hour. If your automation is multi-step browser control rather than request-to-result scraping, SparkProxy's published lineup doesn't offer that.
10. Result-priced scraping with failures free. Evomi's Scraper API bills per 1,000 successful results from $0.20/1K down to $0.13/1K and states: "You only pay for successful requests (200 OK responses). If our API fails to retrieve the data or gets blocked, you are not charged." For a workload with a genuinely uncertain success rate against hard targets, that pushes retry risk onto the vendor instead of your credit balance. Note the credit arithmetic from earlier: the quoted rate tracks credits and a result costs 1 to 6 of them.
11. Procurement and compliance paperwork. Evomi publishes ISO 27001 certification, a completed SOC 2 Type II audit, membership of the Ethical Web Data Collection Initiative, a Swiss operating entity (TeraShift GmbH, Hauptstr. 35A, 8272 Ermatingen) with Terms governed by Swiss law and arbitration under the Swiss Rules of International Arbitration, and a public Trust Center. If your security review wants those artefacts before onboarding, that's a decisive win and we'll concede it without hedging.
12. Ad blocking on Premium Residential. Evomi claims its built-in ad blocker "removes 30-50% of what a page would otherwise download, which cuts your bandwidth bill by the same share". That's Evomi's own unverified figure, but on a metered plan it's a direct discount, and it's a lever that doesn't exist when bandwidth isn't the billing unit. See reducing proxy bandwidth costs for the other levers.

Two things worth adding. Evomi ships an MCP server for AI assistants, installable with pip install evomi-mcp and authenticated with a Public API key, exposing scraping, geo-targeted connection-string generation, sticky-session rotation and usage reads as tools. And on sourcing, Evomi's published position is that IPs come "from a global network of volunteer nodes that opt in to share their connection", with node operators "paid for their participation through PayPal, Gift Cards and some forms of cryptocurrencies", alongside a stated no-KYC-by-default policy, an acceptable use policy at registration, "an extensive list of blacklisted domains" including banks and government sites, and automatic suspension on spam or DDoS patterns. Those are published statements rather than audited facts, and we're quoting them as such. Where residential proxy IPs come from covers how to interrogate any vendor's answer.

The mirror image, and the list is shorter because the flat pack is a narrower product.

• More than about 167 gigabytes of datacenter traffic a month. Straight arithmetic from the like-for-like table above, at Evomi's $0.45/GB pay-as-you-go rate. This is the one row in this list that's a genuine swap, because it's the one product class both vendors sell.
• A fixed $75 that has to cover more than 153 billed residential gigabytes. Budget arithmetic rather than a swap, and only relevant if your targets accept datacenter addresses in the first place. If they don't, this list doesn't apply to you and item 1 of the previous section does.
• Any job that needs an expert filter on most requests. The multiplier divides the crossover. Two or three filters can drop it from 153 GB to under 50.
• Targets whose page weight you can't predict. JS-heavy sites, A/B-tested layouts, anything behind a vendor that serves a 2 MB challenge page on a bad day. On a meter, a redesign is a budget event.
• Retry-heavy work. Evomi's proxy products meter bytes transferred, so on our reading a failed request still bills for the bytes it moved. Evomi publishes a no-charge-on-failure guarantee for the Scraper API only.
• Many machines, one credential problem. If a fleet of workers needs proxy access and you don't want the secret in every image, IP whitelist authentication is the answer and Evomi doesn't sell it.
• Request-dense, tiny-response workloads. Where the 512-byte floor is a structural tax rather than a rounding error.
• Teams that need a fixed line item. Finance can approve $75 a month. Finance cannot approve "$0.49 per gigabyte times an unknown multiplier".
• Anyone who wants to test before handing over a card. 24 hours, no payment details, is a different proposition from a trial that needs billing information and auto-renews.
• Concurrency-bound rather than bandwidth-bound work. If your constraint is parallel connections, buying gigabytes is paying for the wrong axis; see concurrent connections in proxies.

Three numbers settle this for your traffic, and all three are cheap to get.

1. Bytes per response, p50 and p95. Not the average. The p95 is what a retry storm and a page-weight regression will bill you at. Pull a representative sample of your real URLs through SparkProxy's Scraping API with json_response=true, which is the only parameter that returns the billing envelope. The body comes back base64-encoded and must be decoded before you measure or string-match it; format=json converts page content and is a different thing.

curl -s "https://scrape.sparkproxy.io/api/v1" \
  -H "X-API-Key: $SPARK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://www.sparkproxy.io/","render_js":false,"json_response":true}' \
| python -c "import sys,json,base64; d=json.load(sys.stdin); \
b=base64.b64decode(d['body']); \
print(d['status_code'], d['duration_ms'],'ms', d['credits_used'],'credits', len(b),'bytes')"

Batch mode costs 1 credit for the whole batch and only works with render_js=false, which makes it the cheap way to size a sample of static pages:

curl -s -G "https://scrape.sparkproxy.io/api/v1" \
  -H "X-API-Key: $SPARK_API_KEY" \
  --data-urlencode "url=https://www.sparkproxy.io/,https://www.sparkproxy.io/scraping-api/" \
  --data-urlencode "render_js=false"

Rendering defaults to on and costs 5 credits against 1 for a plain fetch, and the plain fetch is roughly 3x faster, so measure both: the bytes a browser pulls and the bytes a plain fetch pulls are different numbers and they bill differently on a metered plan. Add country_code for a specific exit (+5 credits) if geography changes page weight, which it often does on retail sites.

2. Requests per month, including retries and redirect hops. Each hop is a separate billed request at Evomi, floored at 512 bytes.

3. The share of requests that need something beyond country, region or city. That's your multiplier exposure. If it's zero, the 153 billed gigabytes that $75 buys on Evomi's residential plan is the figure to budget against. If it's most of your traffic, divide.

Then price both sides:

# Monthly cost, both units. Evomi rates read from evomi.com on 2026-10-09, USD, ex-VAT.
def evomi_core_monthly(gb, multiplier=1.0):
    billed = gb * multiplier
    if billed <= 100:
        return 49.00                      # 100 GB plan, unused GB do not roll over
    return 49.00 + (billed - 100) * 0.49  # extra data at the same rate

def evomi_core_payg(gb):
    gb = max(gb, 15)                      # 15 GB minimum purchase
    return gb * (0.79 if gb >= 1000 else 0.99)

SPARKPROXY_ENTRY = 75.00                  # flat, unlimited bandwidth

for gb in (10, 25, 50, 100, 153, 250, 500):
    for m in (1.0, 2.0, 4.0):
        print(f"{gb:>4} GB  x{m:<4} "
              f"evomi-plan ${evomi_core_monthly(gb, m):>8.2f}   "
              f"evomi-payg ${evomi_core_payg(gb):>8.2f}   "
              f"flat-pack  ${SPARKPROXY_ENTRY:>7.2f}")

Last step, and the one that actually answers the question: spend Evomi's 100 MB trial allowance with the filters your job needs switched on, then open the dashboard and read the actual-versus-multiplied usage breakdown. That ratio, not $0.49, is your rate. Everything above is arithmetic on published numbers; that one measurement is evidence.