SparkProxy vs ProxyScrape: What a Free List Costs

ProxyScrape describes the free list plainly: "ProxyScrape's free proxy list contains thousands of public HTTP, HTTPS, SOCKS4, and SOCKS5 proxies from 180+ countries, refreshed every minute and verified by automated checkers." Filter by protocol, anonymity, country or latency, export as TXT, JSON or CSV, from the table, the public API, or a GitHub mirror that refreshes every five minutes. No signup. The page says the list "typically holds 20,000+ live proxies across 180+ countries at any time", that anything failing a 15-second timeout is dropped, and that "nine dedicated checkers and three scrapers" do the work.

We read the list three times in one session through that same API. total_records came back as 2,814, then 2,861, then 2,739. total_countries came back as 86, 87 and 92. That is a point-in-time snapshot from one network vantage on one afternoon, not a claim about what the list always holds, so run the call yourself before planning around either number. But on 9 October 2026 the live list was roughly 2,700 to 2,900 entries across 86 to 92 countries, about 14% of the page's headline volume and roughly half its country count.

Composition of the full 2,861-record read, straight from the payload:

Only 22% of the list speaks plain HTTP, so a scraper written against http:// proxies is ignoring most of what it downloaded. The elite share is high, which matters if you care which headers reach the target; our explainer on elite and high-anonymity proxies covers what that tag does and does not guarantee.

The 68% hosting share is an observation about the ip_data.hosting flags in this snapshot, and it says nothing about how any individual proxy came to be open. ProxyScrape's own wording is the right source on origin: "We provide a continuously updated list of open proxies, aggregated from thousands of sources across the web," and in the FAQ, "No, these are public proxies hosted by volunteers on the internet and they come online and go offline constantly."

Most writing about free proxy lists stops at "they don't work very well", which is true and useless, because it treats the list as one undifferentiated blob. The v4 API does not. Every record carries an uptime percentage plus times_alive, times_dead, average_timeout, alive_since and first_seen.

Across the 2,861-record snapshot, uptime had a median of 36.19%. The distribution is the useful part:

Median times_alive was 1,906 against a median times_dead of 3,467, so the typical entry has failed its checker more often than it has passed. The churn figures explain why. Median current uptime streak, taken as now minus alive_since, was about three minutes. Ninety-three percent of entries had been continuously alive for under an hour. Median time since first_seen was 12.4 days, so these are not fresh discoveries churning in and out, they are long-lived addresses that flap. Vendor-reported average_timeout had a median of 6,109 ms, p75 of 7,242 ms, p90 of 8,445 ms and a maximum of 22,815 ms, which is what you would expect from a pool admitted at a 15-second cutoff.

Put the distribution next to the churn and the guidance writes itself. Never consume the list in default order, because three quarters of it will fail you and the field that says so was in the response you already downloaded. Filter on it and you have a few hundred pre-scored endpoints for nothing. If uptime percentages as a concept are new, our piece on proxy uptime and reliability covers how these figures are produced and what they leave out.

Vendor telemetry is one thing. Real requests are another. This section is SparkProxy's own test, not a ProxyScrape figure.

Method: from the 2,861-record snapshot we drew a seeded random sample of 150 entries, issued exactly one GET to http://example.com through each at 30 concurrent with a 25-second timeout, and counted HTTP 200s. We then took the 120 highest-uptime http and socks5 entries (vendor uptime between 91.8% and 100%) and ran the identical test. The harness was validated first: a direct request returned 200, and SparkProxy's own gateway returned 407 through the same curl path, which proves outbound proxying was working rather than silently bypassed.

The median vendor-reported uptime of the random sample was 35.1%. It succeeded on 35% of real requests. That field is calibrated, almost exactly so on this sample, and it is the single most useful thing we learned all day.

Round-trip latency on the 101 filtered successes: median 1.29s, p25 0.58s, p75 3.20s, p90 6.53s, max 22.16s. Sixty-two percent finished under two seconds and 17% took over five. A filtered free pool is not uniformly slow, it has a long tail, and your timeout policy decides whether you pay for that tail or throw away the slowest sixth of a pool that works.

Caveats, plainly. One session, one vantage point, one undemanding target, one date. Nothing here measures ProxyScrape's steady-state performance, nothing here predicts behaviour against a target with real anti-bot defences, and none of it transfers to the paid products. We publish the method so you can repeat it rather than trust it.

The API needs no auth. The exact endpoint we used:

# text output, one protocol://ip:port per line
curl -s "https://api.proxyscrape.com/v4/free-proxy-list/get\
?request=display_proxies&proxy_format=protocolipport&format=text"

# JSON, the format that carries the uptime field
curl -s "https://api.proxyscrape.com/v4/free-proxy-list/get\
?request=display_proxies&proxy_format=protocolipport&format=json" \
  | python -c "import json,sys; d=json.load(sys.stdin); print(d['total_records'], d['total_countries'])"

Swap format=csv for a spreadsheet. Documented filters are protocol, country, anonymity and timeout. Page size defaults to and caps at 2,000 records, with limit, skip and nextpage in the response, so a full read needs pagination through skip. ProxyScrape permits scraping the list and recommends the API or the GitHub mirror over scraping the HTML table.

Pull every page, keep only what scores, write a pool file:

# proxyscrape_pool.py - paginate, then filter on the vendor's own uptime field
import json, urllib.request

BASE = ("https://api.proxyscrape.com/v4/free-proxy-list/get"
        "?request=display_proxies&proxy_format=protocolipport&format=json")
MIN_UPTIME = 90.0          # 6% of the list cleared this on 2026-10-09
MAX_TIMEOUT_MS = 4000      # drop the slow tail before it costs you wall clock

records, skip = [], 0
while True:
    with urllib.request.urlopen(f"{BASE}&limit=2000&skip={skip}") as r:
        page = json.load(r)
    batch = page.get("proxies", [])
    records += batch
    if not batch or len(records) >= page.get("total_records", 0):
        break
    skip += len(batch)

keep = [p for p in records
        if p.get("uptime", 0) >= MIN_UPTIME
        and p.get("average_timeout", 1e9) <= MAX_TIMEOUT_MS
        and p.get("protocol") in ("http", "socks5")]
keep.sort(key=lambda p: -p["uptime"])

with open("pool.txt", "w") as fh:
    for p in keep:
        fh.write(f"{p['protocol']}://{p['ip']}:{p['port']}\n")

print(f"{len(records)} records in, {len(keep)} kept")

Then verify, because a score from the vendor's checker is not a success against your target. This is our loop, cut to one line per proxy:

# verify.sh pool.txt https://your-target.example/page
while read -r p; do
  code=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' \
         --proxy "$p" --max-time 25 "$2")
  echo "$p $code"
done < "$1"

Run that against your real target, not a test page, and keep the winners. The gap between our 35% and 84% runs is entirely this step plus the uptime filter, and both are free. Our proxy testing guide goes further on latency percentiles and detecting transparent proxies.

The scripts above are the easy part. Running a free list in production means owning all of this, forever:

None of it is hard. All of it is yours. Price it in your own hours rather than ours:

free_path_cost  = (build_hours + monthly_hours) x your_loaded_hourly_rate
paid_path_cost  = plan_price

SparkProxy's entry plan is $75 a month excluding VAT, per sparkproxy.io on 9 October 2026, with unlimited bandwidth and no byte meter. At a $60/hour loaded rate, $75 is 75 minutes. So the test is simple: if keeping a free pool alive costs more than about an hour and a quarter of attention a month, it is already the more expensive option, before you count the 35% success rate. A one-off build of 8 to 14 hours, a fair range for the table above done properly, is six to eleven months of the entry plan spent before you serve a single useful request. Replace those hours with your own and set your own rate. The arithmetic is the point, not our numbers.

Free still wins outright in one case: when your hours cost nothing because you are learning, prototyping, or building a CI fixture that needs to exercise dead-proxy handling. Nothing paid competes with free there, and we won't pretend otherwise.

ProxyScrape is unusually direct about this, so we will quote rather than characterise. From the free-list FAQ: "These proxies are public and you can use them for anything you want but some of the proxies can be banned on the services you want to use." On safety: "The proxies we provide are public proxies, this means the proxy may be infected." On capacity: "We don't know how much bandwidth the free proxies have. If their limits are exceeded, they will probably stop working."

That is the vendor describing the operating model accurately. Nobody signed up to carry your traffic, nobody is accountable when it stops, and nobody can tell you who sits on the other end of any given port. There is also no aggregate uptime or working-rate figure published for the list as a whole, which is consistent rather than evasive: the page says the proxies "come online and go offline constantly." The 99.9% uptime figures elsewhere on proxyscrape.com belong to the paid products. Don't carry them across.

The rule we use: a free list is fine for fetching public pages whose contents you wouldn't mind a stranger reading, and wrong for anything carrying a credential, a session cookie, a customer identifier or an API key. That isn't a dig at ProxyScrape, whose own FAQ says the same thing more bluntly. It is the structural property of an open relay you did not configure.

The paid lineup has no marketing tier names except the SERP API. Products are named for what they are: Residential, Unlimited Residential, Premium Datacenter (shared), Dedicated Datacenter, Dedicated ISP, Mobile, Google SERP API. Every configurator carries a "Regular" and an "Enterprise" toggle. The SERP API is the one that prices its enterprise tiers outright: the payload marks Scale, Business and Enterprise as enterprise and gives all three a figure, which you will find in the table below. Everywhere else Enterprise is "Talk to sales", as is anything above 10 TB bandwidth, 1,000 dedicated proxies, 5,000 ISP IPs or 15M SERP requests.

Residential, per GB (pricing API, type=new_residential, 9 October 2026, USD excl. VAT):

Read the top two rows again. The 2 GB bundle costs less in absolute terms than the 1 GB bundle, $6.80 against $7.50, so there is never a reason to buy the 1 GB rung. Entry testing is advertised separately as "Try 1GB for $1."

Terms are 30, 60 and 90 days plus Non-Expiry, and longer terms cost more per GB, not less: the same 10 GB is $28.50 at 30 days, $30.50 at 60, $32.50 at 90 and $38 Non-Expiry. Bandwidth that never expires is a genuine structural product rather than a markup dressed as one, and it is the right shape for lumpy work. If you have ever binned unused gigabytes at month end, read our note on monthly versus annual proxy plans and then look hard at that column.

Residential features per the product page: 120M+ IPs, country and city targeting plus "OS, ASN, UDP targeting", rotating or sticky sessions, unlimited concurrency, HTTP and SOCKS5 with UDP, user:pass auth. The ASN and OS targeting is advertised but its syntax is not in the public docs, which cover only -country-, -state- and -city- and say to target a state or a city, not both. The documented host is rp.scrapegw.com, sticky sessions use user-session-{id}-lifetime-{minutes} and combine with geo as user-country-us-session-1235469420-lifetime-15, and the docs publish a residential rate limit of "approximately 10,000-12,000 requests per second per user". That is a high, unusually specific ceiling and it deserves credit. The docs are candid about the awkward part too: "The proxy IP is only kept while the node serving it remains online. If the node goes offline, the IP rotates automatically, even if the session duration has not yet expired."

Unlimited Residential is billed by port speed in Mbps and by term, not by the gigabyte:

Listed features: unlimited bandwidth with no overage fees, 4M+ rotating residential IPs, 180+ geo targets, sticky sessions up to 12 hours, unlimited concurrency. UDP over SOCKS5 is a paid add-on here rather than included. The payload carries v2_discount_percent = 10, and the live page showed $266 struck through from $296 with "Save $30", consistent with that discount applying at display time. The page also runs a savings calculator benchmarked against "$1.1 / GB" and a countdown reading "Offer expires in 24h 0m 0s", worth knowing before you read that discount as a deadline.

Datacenter, shared and dedicated. Shared (Premium) is priced per proxy count at 30 days with the 250 GB bandwidth tier, location "mixed". Dedicated is per proxy, billed monthly, identical across all eight locations (us, ca, de, fr, it, jp, in, tw).

Both the "From $0.02 / Proxy" and "From $1.4/proxy" headlines are accurate and slightly conservative. The dedicated ladder is not monotonic, and the kink is worth money: 400 units price at $1.40 each while 500 price at $1.50, and 750 units at $787.50 cost only $37.50 more in total than 500 at $750. Check the rung above yours before you buy. Shared terms are 1, 7, 14 and 30 days, priced identically across all ten locations (br, ca, de, es, fr, gb, it, mixed, th, us) at a given tier, where that tier is offered, because the proxy-count ladder does not run the same distance in every location. The page claims instant access to 40,000 IPs, a 10 Gbps network and no session length limit. Dedicated adds private IPs in eight countries, unlimited bandwidth under fair use, "No rate limit*" and monthly billing with "Cancel or change tier anytime".

Dedicated ISP is per IP with unlimited bandwidth, 17 locations, HTTP plus SOCKS5, volume stops at 5/20/50/100 IPs and terms of 1, 7, 30 and 90 days. Headline: "starting from $1.65 per proxy". We could not retrieve an ISP ladder, because every pricing API type we tried for it returned a pricing error, so it is configurator-only. The two solid figures are that headline and the live default, which on 9 October 2026 read $17.20 excl. VAT for 5 IPs over 30 days at "United States, Comcast", or $3.44 per IP. Don't interpolate the 20, 50 or 100-IP rungs from two points; price your own combination. Carrier-level selection is a real capability, and our comparison of rotating versus static residential proxies explains which jobs need it.

Mobile is per GB on the same terms, slider stops at 1 GB, 75 GB and 1,000 GB, headline "from $1.15/GB", and the live default of 1 GB for 30 days read $7.50 excl. VAT. One observation, stated narrowly: the mobile configurator requested the same pricing endpoint as the residential one, type=new_residential, and its 1 GB / 30-day price matched the residential ladder's entry exactly. That establishes the two products were priced off one shared ladder on that date. It establishes nothing about the underlying IP pools, and we make no claim about them. Since no separate mobile ladder could be retrieved, $7.50 and the $1.15/GB headline are the only mobile figures we will assert.

Google SERP API is the one product with named tiers, per 1,000 requests, billed monthly:

One request equals one SERP of up to 10 results, up to 100 organic results in a call, geo-targeting by country, city and device, structured JSON. The page carries both a "Start Free Trial" and a "Get Approved for Trial Access" CTA, and no trial terms are published for either.

On sourcing for the paid residential pool, ProxyScrape publishes: "We are committed to responsible proxy sourcing. Our residential IPs are obtained through transparent partnerships and user consent, ensuring compliance and long-term sustainability." The product page also says "120M+ ethically sourced IPs." Those are the vendor's own statements; we can't verify them and won't characterise them either way.

This is the pricing nuance that changes the comparison, and almost nobody reports it.

The $25 headline for 1,000 shared datacenter proxies over 30 days is not an unmetered plan. It is the 250 GB bandwidth tier. The configurator sells bandwidth as a fourth axis alongside proxy count, location and term, and at 30 days with location "mixed", the same 1,000 proxies price like this:

Bandwidth key 0 is the dearest of the four, consistent with 0 meaning unmetered or fair-use rather than zero allowance. So the honest reading is: $25 buys a quarter-terabyte, and unmetered costs $75.

And "unmetered" there has a published number behind it. Terms Article 17 applies a Fair Use Policy "exclusively to Proxyscrape's datacenter proxy Services, including but not limited to dedicated datacenter proxies, shared datacenter proxies, and premium datacenter proxies, including plans marketed as unlimited". Article 17.3 gives the formula: "the Purchaser receives 1 TB of bandwidth for every $5 paid for the subscription plan. A minimum allowance of 10 TB always applies", taking the greater of the two. So a $75 unmetered datacenter plan carries 15 TB, and anything priced up to $50 lands on the 10 TB floor.

Enforcement is published too. Exceeding the allowance lets ProxyScrape "Apply additional usage charges of $5 per TB for excess bandwidth", require an upgrade, or throttle, and "Additional charges, throttling, or plan adjustments may be applied without prior approval from the Purchaser where usage exceeds the included allowance." Article 17.5 says ProxyScrape "may apply temporary or progressive throttling to bandwidth usage", and that throttling applied under the policy "shall not be considered a service interruption, defect, or failure to provide the Services". ProxyScrape also reserves the right to change the ratio, the minimum or the pricing at any time.

None of that is unreasonable. Publishing the formula is more transparent than the typical fair-use clause, which says "excessive use" and stops there. The point is that it exists, it is arithmetic, and you can plan against it.

SparkProxy's difference here is structural rather than generous. Unlimited bandwidth is the billing model, not an allowance: plans are packs priced by concurrency, with no byte meter, no overage line and no fair-use divisor to compute. The ladder on sparkproxy.io reads Starter $75 for 100 threads, Core $140 for 250, Boost $240 for 500 and Plus $440 for 1,000, all unlimited bandwidth, on 1M+ premium IPs across 80+ countries with 1 Gbps ports, random per-request rotation or 5-minute auto-rotation, HTTP/HTTPS/SOCKS5, and IP whitelist or user:pass auth. Prices exclude VAT/GST, and the trial is 24 hours at 250 threads with no credit card. We've written up whether unlimited bandwidth is worth paying for, including where it is not.

A $75-against-$75 read on 9 October 2026: ProxyScrape gives you 1,000 shared datacenter IPs with a 15 TB computed allowance and progressive throttling above it. SparkProxy gives you 100 concurrent threads against a 1M+ rotating pool with no allowance to compute. Which is better depends entirely on whether your constraint is distinct exit addresses or transfer volume.

We are flagging these rather than resolving them, because only ProxyScrape can resolve them and because anyone pricing a plan needs to know to check at checkout.

No tier we could read returned $35.50, and the same page's live product card showed 5 GB at $14.25. The residential page title advertises "Up to 25% OFF" and the unlimited-residential payload carries a 10% discount field, while the residential payload carried no discount field at all, so we cannot tell you whether the API figures are list or promotional prices. Both numbers are dated above. Confirm at checkout.

The sticky-session conflict is the one that will bite an engineer. Don't design a session strategy around 24 hours, 12 hours or 120 minutes until support tells you in writing which figure binds your plan.

Reliability marketing across the paid products is similarly unaudited. 99.9% uptime, 99.9% success rate and "99.95%+ success rate" all appear, one page carrying two of them, alongside "0.8s average response time", "<1000ms" and "< 500 ms" figures and the SERP API's "99.9% uptime SLA" that its own FAQ withdraws in the table above. No methodology, measurement window or SLA document is published for any of it, and none can be tested without a paid account. Treat them as claims, along with "Trusted by 20,000+ Developers", which appears on every product page with no stated basis.

Four clauses are worth reading before you put a card in.

Use-case review. The terms state: "In order to access the Services of our Website, you may be requested to complete the verification process, where you must explain how you use the proxies and which services you will access with the proxies. We will do a background check, based on the information you gave us, to see if your data is linked to any illegal activities." Refusing the form or supplying false information allows account deletion without warning, and in that case "we will not reimburse you for the time you paid for and did not get to use". Budget for a review before you commit to a deadline.

Refunds. The terms summary says: "By purchasing, you waive the standard 14-day consumer withdrawal right. Limited 3-day refund applies, with conditions." The 3-day window requires all of: the purchase is not an account upgrade, "The Purchaser has not used more than 1 GB of traffic", payment by credit card or PayPal, "The purchase does not exceed $100", and no refund to the same purchaser in the same calendar month. Suspended purchasers "can never rely on the right to withdraw". Our proxy trials and refund policies comparison puts that next to other vendors. SparkProxy's own paid plans are non-refundable, which is exactly why the 24-hour trial exists; spend it on your real target.

Trials differ sharply by product, per the docs. Premium datacenter: "A free trial is available for our Premium proxy plan. Some limitations apply." Dedicated: "We do not currently offer a free trial for Dedicated proxies." Residential: no free trial, you "purchase a 1 GB test plan for $1". ISP advertises a 7-day trial and "5 Proxies for $5.92". So the only genuinely free trial is on shared datacenter, and what "some limitations apply" means in duration, volume or card requirement is unpublished.

Resale and sharing are restricted: "The Purchaser is not permitted to resell, share, distribute, or otherwise make the Services available to multiple end users, whether directly or indirectly, without the prior explicit written consent of Proxyscrape." Internal use across one organisation counts as one end user, and a one-to-one resale of a whole plan is allowed if the original purchaser stays liable. If you run a multi-tenant product on proxies, get that consent in writing first. Liability is capped at "the total amount paid by you for the Services purchased", and free or promotional access is "provided on a discretionary basis, without any guarantee as to duration, availability, pricing conditions, or continued access".

Now the arithmetic both vendors would rather you skipped. ProxyScrape meters residential and mobile by the gigabyte, sells datacenter by IP count with a bandwidth tier attached, and sells unlimited residential by port speed. SparkProxy sells a plan. Those are different shapes, not different prices, and the shape decides the winner.

Take the 30-day residential ladder against the $75 entry plan. Twenty gigabytes costs $53, comfortably under. The next rung, 40 GB, costs $106, comfortably over. At the 20 GB rate of $2.65/GB, $75 of metered traffic is 28.3 GB. So the crossover sits between the 20 GB and 40 GB rungs, which in practice means 25 to 35 GB depending on which rung your real usage lands on and which term you pick.

Two honest qualifications. These are different IP classes, so the table compares billing shape rather than equivalent products, and if your job genuinely needs residential exits then the metered ladder is what you are choosing between. And bundles are discrete, so needing 25 GB means buying the 40 GB rung or topping up, which pushes the real crossover down rather than up.

The last row decides most migrations. A meter costs certainty as well as money: retries, block pages, redirects and oversized assets all bill, and none of them are in your estimate. A plan bills the same whether a page weighs 40 KB or 4 MB. For the general version of that argument rather than this vendor pair, see per-IP versus per-GB proxy pricing.

For a managed alternative to both, SparkProxy's Scraping API bills credits rather than bytes: 1,000 free on signup, 1 credit for a plain fetch, 5 when rendering. The cheap path is explicit:

# render_js defaults to TRUE and costs 5 credits; turn it off for 1 credit and ~3x the speed
curl -s -X POST https://scrape.sparkproxy.io/api/v1 \
  -H "X-API-Key: sk-xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
        "url": "https://target.example/listing",
        "render_js": false,
        "format": "md"
      }'

That body is the 1-credit request, and what you add to it decides the rest. format only selects content conversion (html, md, mdx, json, screenshot, pdf) and costs nothing. For the job envelope with job_id, status_code, duration_ms and credits_used, set json_response=true and base64-decode the body before matching anything in it. country_code and js_scenario each add 5 credits. Routing costs more than rendering: proxy_type=premium moves the request to the premium tier at 10 credits without JS and 25 with it, per the credit table in the docs, while ad_free adds nothing. So the same page bills 1, 5, 10 or 25 credits depending on two fields. Read that table before you write the loop. extract_rules replaces the normal response and must not be combined with json_response, and batch mode works only with render_js=false for 1 credit per batch.

A comparison where the vendor writing it wins every axis is marketing. Here are the jobs where we would tell you to buy ProxyScrape, and we mean all ten.

1. Small and occasional residential work. A gigabyte for $1 as a test, then 1 GB at $7.50 or 5 GB at $14.25 on a 30-day term. SparkProxy starts at $75. If you pull a few gigabytes a month, pay ProxyScrape and ignore everything above.
2. Irregular, bursty or seasonal jobs. Non-Expiry bandwidth beats any monthly pack when a project stalls for two months, because a monthly plan silently bins what you don't spend. SparkProxy has no equivalent and shouldn't pretend to.
3. Learning, prototyping, CI fixtures and throwaway checks. The free list, no signup, documented API, GitHub mirror. Filtered on uptime it gives a few hundred working endpoints for nothing, and it is the correct way to test that your own rotation logic handles dead proxies.
4. Large fleets of distinct datacenter IPs. Forty thousand shared proxies for $750 over 30 days is $0.0187 each, and 30,000 for $553 is $0.0184. Check the location first, because those two rungs exist only at "mixed": single-country ceilings in the same payload run from 1,000 proxies (Spain, Italy, Thailand) through 2,000 (Canada), 3,000 (Germany, UK), 4,000 (Brazil, France) to 20,000 (US). When the constraint is how many separate exit addresses you need rather than how much traffic, the per-IP model fits the problem better.
5. Private, exclusive, static addresses. Dedicated datacenter IPs across eight locations down to $1.00 each at 1,000 units, unlimited under fair use. A rotating pool is the wrong product for an allowlisted QA target.
6. Carrier-specific static residential. Dedicated ISP across 17 locations with choices like "United States, Comcast" exposed in the configurator. If your target cares which ISP you appear to be on, no rotating datacenter pool substitutes.
7. Sustained high-throughput collection. Unlimited Residential priced in Mbps, $1,425 for 100 Mbps over 30 days up to $5,537 for 1,000 Mbps, plus single-day options at $190 to $1,102. If you are saturating a pipe continuously, paying for speed beats paying for gigabytes, and a one-day term makes a short intense campaign practical.
8. Very large, well-forecast bandwidth buyers. The ladder bottoms out at $1.05/GB for 10 TB on a 30-day term. If your traffic really is bandwidth-shaped, predictable and big, price against that rather than dismissing it.
9. Google SERP data as a product. Named tiers from $41 for 100,000 requests down to $0.225 per 1,000 at 10M, with structured JSON and device-level geo-targeting. A team that wants results rather than a proxy to go and fetch them should buy this instead of building a scraper on any pool.
10. Engineers who want published ceilings. A documented 10,000-12,000 requests/second residential limit, a sticky-session maximum of 24 hours in the docs with the exact username syntax for setting it, datacenter terms of 1, 7, 14 and 30 days, and configurators showing real stock ("Only 665 proxies available in United States right now"). On the sticky figure, read the conflict in the table above before you rely on it: 24 hours is the docs' number and the /pricing table says 120 minutes instead, so what earns the credit is that a ceiling and a syntax are published at all, not that either number binds your plan. Publishing the stock ceiling before you pay is a courtesy, and admitting in the docs that a dropped node rotates your sticky IP early is the kind of honesty you can design against.

The mirror image, with the same honesty.

SparkProxy is the better buy when traffic is heavy or simply unforecastable, because the bill doesn't move with bytes. It fits when your targets rate-limit per IP and you need many addresses in flight rather than a fixed set you own, since the pool is 1M+ IPs across 80+ countries with per-request random rotation or 5-minute auto-rotation. It fits when retries and heavy pages would otherwise land on an invoice, when finance wants one line item that doesn't change, and when you want to test on your real target before paying, which is what the 24-hour no-card trial is for. For managed collection, the Scraping API prices rendering explicitly at 5 credits against 1 for a plain fetch, so you choose the cost rather than discovering it.

What SparkProxy does not sell, plainly: no standalone residential or mobile product, no dedicated or ISP addresses you keep, no Mbps-priced unmetered residential port, no bandwidth tier that never expires, no managed SERP endpoint. Six of the ten jobs above need one of those. If yours is one of them, buy ProxyScrape.

The cleanest rule we can give: if your monthly residential traffic is under about 25 GB, or you need an address you own, buy ProxyScrape. If you can't predict the number, or the number is large, buy the plan. And if you are still deciding which IP class the job even needs, settle that first, because picking the wrong class costs more than picking the wrong vendor.