SparkProxy vs Infatica: Pool Depth by Country

Start with the awkward part. Infatica states its own residential pool size two different ways on its own pages. The homepage hero reads "45M+ ethically sourced proxies across 195+ countries" and the pricing table lists "45M+ IPs", while the homepage product card reads "40+ Millions IP Addresses around the world" and the residential page is titled "40 M+ Fast Proxy IPs" and says "Each plan includes 40 million+ IPs" on the same page as "45M+ proxy pool". We are not picking a winner. The vendor says it both ways, which is the first clue about what a headline is worth.

SparkProxy publishes 1M+ premium IPs across 80+ countries. Put that next to 40M+ and you have compared a rotating datacenter pool with a residential pool: different address classes, different unit cost, different ban profile. If you are not sure which class your targets need, settle that first with residential vs datacenter proxies; it decides more than the vendor choice does.

Here is what each company publishes per product, which is already more useful than any headline.

Now the arithmetic almost nobody runs. Infatica does publish exact per-country residential counts for eleven countries, under the heading "Global Portfolio of Residential IPs". Add them up and they come to 4,470,205 addresses, roughly 11% of a 40M+ headline. The deepest single country on that list, Brazil at 1,123,823, is about 2.8% of the headline. Germany, at 116,173, is about one three-hundred-and-forty-fourth of it.

That is not a gotcha aimed at Infatica. It is the structural truth of every pool number in this market, ours included: a global total sums roughly two hundred jurisdictions, and you buy traffic in one or two of them at a time. Proxy pool size claims explained covers the general case. This post is about what to do instead.

Effective depth is the number of distinct exit addresses you can actually draw in one country, inside one rotation window, after the vendor's routing rules, session settings, subnet concentration and whatever is online right now have all had their say. It is not the pool size. It is the pool size after every filter between you and an exit.

Three things depend on it, and nothing else about the pool does.

Repeat-IP rate. Low depth means you see the same addresses again inside the window a target remembers you. A defender counting requests per address does not care that the vendor owns forty million more elsewhere.

Recovery after a block. When an exit gets a 403, you want the next request on an address the target has never seen. Shallow depth turns that into a wait rather than a retry.

Usable concurrency. The distinct addresses you need is division: requests per hour you need, over requests per hour the target tolerates from one address.

The last row is the one to sit with. Two hundred thousand requests an hour against a target tolerating five per address needs forty thousand distinct identities, which is 62% of every Saudi residential address Infatica publishes a figure for. At that point the country, not the vendor, is your constraint. How many proxies do you need for scraping works the sizing through, and understanding concurrent connections in proxies covers the thread side of the same equation.

This needs saying before any depth comparison: the two vendors are not substitutes.

SparkProxy's homepage sells datacenter proxies only. It describes the product as "premium datacenter proxies with unlimited bandwidth, 1M+ IPs across 80+ countries, and 99.9% uptime", and the words residential, mobile and ISP proxy do not appear on it as products. Infatica sells six classes: residential, premium IPv6 residential, mobile, shared datacenter, static ISP and dedicated datacenter. One exception runs the other way, and you should hear it from us: our own Scraping API docs do document a residential path. premium_proxy=true routes "through a residential proxy from our premium pool" at 10 credits a request without rendering and 25 with it, and proxy_type=premium selects a pool the docs label "High-quality residential IPs". No pool size or country breakdown is published for it, and it bills per request rather than per plan, so it covers a residential-exit requirement at API volumes and not at proxy volumes. For a mobile, ISP or IPv6-residential exit, or residential traffic at proxy-plan scale, Infatica is the only one of the two that can do the work.

Depth only means something inside a class. The Infatica product that competes with SparkProxy's rotating datacenter pool is Shared Datacenter at 500K+ addresses, and here is the detail that reframes the whole transparency argument: Infatica's eleven-country table is residential. We found no per-country figures for either vendor's datacenter pools. On the class that goes head to head, the disclosure gap closes to zero, and neither of us gives you a number for Germany.

Infatica's published counts, with each one as a share of a 40M headline:

Read the ordering, because it is the most useful thing on Infatica's site. The United States is ninth of the eleven countries Infatica chose to disclose. Germany is tenth. If your workload is US-heavy, the number governing your repeat rate is 226,090, not 40 million, and the gap between those two is the whole argument of this post.

Coverage breadth is reported three incompatible ways on Infatica's own properties. The marketing claim is "195+ countries". The location index links 107 individual country pages, which counts published pages rather than guaranteeing coverage. The API docs publish a table of 249 unique ISO-2 codes accepted as _c_ values, and it includes AQ for Antarctica, so it is a parameter reference rather than an inventory. Availability beyond the eleven countries is not published, so treat 195+ as a vendor claim.

Individual location pages are inconsistent too. The Hungary page states "Explore a vast pool of over 120,000 Hungary IP addresses at Infatica." The Germany page gives no German figure in prose at all, only the global "over 40 million residential IP addresses" in its FAQ. Both embed the same eleven-country table.

Our side of this table has a hole in it and we are not going to paper over it. SparkProxy publishes 82 named countries and territories under the heading "80+ Supported Locations", grouped into six regions, and publishes no per-country IP count for any of them. On per-country disclosure the asymmetry runs against us. If your decision depends on a published figure for one market, Infatica is the only one of the two vendors that hands you one.

What survives that concession is narrower and still worth acting on. Neither headline is auditable by a buyer, one vendor contradicts its own headline on the same page, and a 249-row code table is a list of accepted parameters. The only pool figure you can trust is the one you measure, which is why the next three sections exist. If you score vendors formally, how to score proxy providers objectively puts measured numbers above published ones.

Depth bites hardest where three things line up: the country is a small slice of any global pool, the targets rate-limit per address, and geo-pricing or geo-content forces the exit into that country so you cannot spill into a neighbour. In practice that means Germany, the Netherlands, Poland, Switzerland, Austria, Ireland, Portugal, Hungary and the Nordics; Japan, South Korea, Taiwan, Singapore, Australia and New Zealand; the UAE, Saudi Arabia, Israel and Turkey; Mexico, Argentina, Chile and Colombia. Retail, travel, grocery delivery, insurance quotes and streaming catalogues all price by country and all check the exit.

Infatica's own figures show how wide the spread gets even among the markets it discloses. Saudi Arabia at 64,697 is roughly one seventeenth of Brazil at 1,123,823. Germany is about one tenth of Brazil. Same vendor, same product, same price per gigabyte, an order of magnitude apart in the number that governs your block rate.

Then there are the markets nobody publishes a figure for. Norway, Finland, Chile, Portugal, New Zealand and most of the Gulf are absent from the eleven-country table, and the Germany page shows an individual location page may not fill the gap. There the published number does not exist at either vendor and measurement is the only option. Two methods exist and they are not interchangeable: regional vs global proxy pools estimates depth from the overlap between two batches captured about thirty minutes apart, which is the one to use when supply swings by the hour, while the single-sample estimator below is the faster one for a vendor bake-off you have to finish inside a trial window. What does geo-targeting mean in proxies covers how the pin itself is implemented.

Five steps. Budget an afternoon per vendor, plus a day for Infatica's identity verification.

Step one: size the sample before you run it. Repeats, not distinct addresses, carry the information. Expected repeats in a sample run at roughly N squared over 2D, so pinning a depth D to within about ten percent wants around a hundred expected repeats, which means N of about the square root of 200D.

import math

def samples_for(depth, want_repeats=100):
    """Sample size that yields ~want_repeats collisions against a pool of `depth`."""
    return math.ceil(math.sqrt(2 * depth * want_repeats))

The last row is why headline figures are not testable on a trial, in either vendor's favour. Confirming forty million needs roughly ninety thousand sampled requests inside one rotation window. Confirming Germany needs about forty-eight hundred, which is an afternoon.

Step two: pin the country and read back the exit address. On SparkProxy the documented pin is the Scraping API's country_code parameter, documented as "an ISO 3166-1 alpha-2 code (e.g. US, GB, DE)", so send it uppercase. A plain HTTP fetch is 1 credit with render_js=false, and country_code adds 5, so each pinned sample costs 6 credits. The 1,000 free credits at signup are therefore about 166 pinned fetches: a spot check, not a census. Use the API for the pin and the 24-hour proxy trial for volume.

curl -s -H "X-API-Key: $SPARKPROXY_API_KEY" \
  --get "https://scrape.sparkproxy.io/api/v1" \
  --data-urlencode "url=https://api.ipify.org/?format=json" \
  --data-urlencode "render_js=false" \
  --data-urlencode "country_code=DE" \
  --data-urlencode "json_response=true" \
| python3 -c "import sys, json, base64; e = json.load(sys.stdin); \
print(e['status_code'], e['credits_used'], e['duration_ms'], e['job_id']); \
print(base64.b64decode(e['body']).decode())"

Two details that cost people hours. json_response=true is the only thing that returns the envelope, and the envelope's body is base64, so decode it before any string matching. The format parameter selects content conversion only (html, md, mdx, json, screenshot, pdf), so format=json is not a request for the envelope. extract_rules replaces the normal response with an extracted object and must not be combined with json_response.

Step three: run the volume sample through the proxy, with the country pinned. The 24-hour trial gives 250 threads of USA and worldwide rotating proxies with no card, and bandwidth is unlimited on every plan, so a few thousand IP echoes cost nothing in traffic. The pin matters more than the volume here. The trial is advertised as "250 threads of USA & Worldwide rotating proxies", so an unpinned run measures the worldwide pool and tells you nothing about Germany. SparkProxy's connection panel publishes the proxy username in the form user-country-us, which is where the pin goes; the published example only shows the US form, so confirm the segment or the endpoint for your own target market in the dashboard before you start.

import json, os
from concurrent.futures import ThreadPoolExecutor
import requests

# The country pin lives in the proxy username (published form: user-country-us).
# An UNPINNED gateway samples the worldwide pool, not one country, and every
# per-country number below is then meaningless. Confirm yours in the dashboard.
COUNTRY = "de"
GATEWAY = os.environ["SPARKPROXY_GATEWAY"]          # host:port from your dashboard
USER = f'{os.environ["SPARKPROXY_USER"]}-country-{COUNTRY}'
PWD = os.environ["SPARKPROXY_PASS"]
ECHO = "https://api.ipify.org/?format=json"         # any echo service works
N = 4800                                            # samples_for(116_173), Germany

proxies = {
    "http":  f"http://{USER}:{PWD}@{GATEWAY}",
    "https": f"http://{USER}:{PWD}@{GATEWAY}",
}

def one(_):
    try:
        r = requests.get(ECHO, proxies=proxies, timeout=20)
        return r.json()["ip"] if r.status_code == 200 else None
    except requests.RequestException:
        return None

with ThreadPoolExecutor(max_workers=200) as pool:   # under the 250-thread trial cap
    ips = [ip for ip in pool.map(one, range(N)) if ip]

with open(f"sample-{COUNTRY}.jsonl", "w") as fh:
    for ip in ips:
        fh.write(json.dumps({"ip": ip}) + "\n")

print(len(ips), "successful samples,", len(set(ips)), "distinct")
print(len({ip.rsplit(".", 1)[0] for ip in ips}), "distinct /24s")

Check the first dozen addresses against a geolocation lookup before you let the run finish: if they are not in the country you pinned, you are measuring the global pool and none of the per-country figures above apply to your result.

Step four: the same sample on the Infatica side. Infatica's concurrency model is ports, not threads. Its docs state "For simultaneous requests, please use different ports within the 10000-10999 range. Note: Each port corresponds to a unique IP address", that a residential proxy list "has up to 1000 ports that you can work with at the same time", and that a mobile list has up to 100. The country goes in the username as _c_DE.

# Infatica: country in the username, one exit IP per port, ports 10000-10999.
# Syntax per infatica.io/documentation/api-tool/ , read 2026-10-09.
for port in $(seq 10000 10099); do
  curl -s --max-time 20 \
    -x "http://${INFATICA_USER}_c_DE:${INFATICA_PASS}@pool.infatica.io:${port}" \
    "https://api.ipify.org/?format=json"
  echo
done | sort -u | wc -l

Three things to know before you run that. Infatica's proxy trials are paid, not free: the pricing page shows "Any for $4.00 7 days trial" for residential, $6.00 for IPv6, $8.00 for mobile and $3.00 for shared datacenter, each 7 days. The traffic allowance is published for only two of the four, and in the docs rather than on the pricing page: residential is "a seven-day Trial for only $4 with 1 GB of traffic" and mobile "a seven-day Trial for only $8 with 1 GB of traffic", both "available for Credit Card and PayPal only". We found no published allowance for the IPv6 or shared-datacenter trial, so ask before you buy one to benchmark with. Identity verification comes first; buying a trial or plan redirects you "to the verification page, where you must complete a quick KYC verification, take photos of your documents, and selfies", and the Trust Center states "All paying customers complete identity verification before being granted access to proxy and scraping services." And pool.infatica.io is a single GeoDNS hostname that "resolves to the nearest Infatica gateway based on your server's location", with published gateways in Amsterdam, New York, California and Tokyo, so your first hop is one of those whatever country you pin. SparkProxy publishes a 1 Gbps port speed and no gateway list either, so measure latency from your own region rather than trusting anyone's response-time claim. How to run a proxy provider trial has the checklist, and why proxy providers require KYC and use case approval explains the verification step.

Step five: measure recovery, not just distinctness. Depth only pays off if a fresh address arrives quickly after a block.

import time
from collections import deque

seen = deque(maxlen=500)      # addresses the target has recently seen from you
blocked_at, recovery = None, []

for _ in range(2000):
    ip, status = fetch_through_proxy(TARGET)   # your own wrapper
    if status in (403, 429):
        blocked_at = blocked_at or time.monotonic()
        continue
    if blocked_at and ip not in seen:
        recovery.append(time.monotonic() - blocked_at)
        blocked_at = None
    seen.append(ip)

recovery.sort()
print("median seconds to a fresh exit after a block:",
      recovery[len(recovery) // 2] if recovery else "no blocks observed")

Convert distinct addresses into an effective-depth estimate by solving K = D times (1 minus e to the minus N over D). Bisection does it in a dozen lines.

import math

def effective_depth(n_samples, n_distinct, ceiling=50_000_000):
    """Solve n_distinct = D * (1 - exp(-n_samples / D)) for D."""
    if n_distinct >= n_samples:
        return None            # no repeats at all: sample too small to bound the pool
    lo, hi = float(n_distinct), float(ceiling)
    for _ in range(200):
        mid = (lo + hi) / 2
        if mid * (1 - math.exp(-n_samples / mid)) < n_distinct:
            lo = mid
        else:
            hi = mid
    return round((lo + hi) / 2)

print(effective_depth(1000, 800))   # ~2,150
print(effective_depth(1000, 950))   # ~9,700

Look at the top row again. A 1,000-request sample with a single repeat only bounds the reachable set at around half a million addresses. Against a 40M pool you would expect about 0.0125 repeats, which rounds to none, so a clean thousand-request run is exactly what both a 500,000-address pool and a 40,000,000-address pool would produce. The headline is not falsifiable at trial scale in either direction, which is a reason to stop buying on headline pool size rather than evidence against anyone.

Three readings to act on:

• Estimated depth is ten times or more your required distinct IPs. Depth is not your problem. Spend the time on fingerprinting and request pacing.
• Estimated depth is one to three times what you need. You will feel this on recovery. Expect repeats inside the target's memory window and budget retries, which on a per-gigabyte vendor means budgeting money.
• Estimated depth is below what you need. The country cannot carry the job at that rate. No rotation setting fixes a pool that is too shallow; lower the rate, add a second vendor for that country, or change IP class.

Check subnet concentration in the same pass, because distinct addresses are not distinct identities. If 1,000 samples land in 40 distinct /24 blocks, a defender erases your whole sample with 40 firewall rules. The distinct-/24 line in step three gives you that number for free; feed the same prefix list to RDAP for the operator view. Read the ASN count as the floor under everything else: two or three distinct ASNs behind a few thousand addresses means one or two operators carry the whole country slice, and a single operator-level block at the target takes all of it down at once, however many individual IPs you counted. What are subnet proxies explains why the /24 spread matters more than the raw count, ASN targeted proxies covers the operator layer, and what is proxy success rate and how to measure it keeps depth and success rate on the same traffic.

The two vendors meter different units of scarcity, and that decides more than any per-gigabyte rate does. Infatica meters consumed gigabytes on four of its six products. SparkProxy meters concurrent threads and ships unlimited bandwidth on every plan.

Depth is where the two models diverge on the invoice. On a per-gigabyte meter a shallow pool is metered twice: you pay for the blocked response and again for the retry, so a 20% block rate means paying for 1.25 times your useful traffic. On a flat thread plan the retry costs wall-clock time and nothing else.

Infatica residential, monthly, with the effective rate worked out:

Annual billing is advertised as 20% off monthly: $922 for 300 GB ($3.07/GB), $3,456 for 1,200 GB ($2.88), $6,720 for 2,892 GB ($2.32), $12,960 for 6,000 GB ($2.16) and $24,960 for 12,000 GB ($2.08). That $2.08/GB is the cheapest residential rate reachable anywhere on the published page, and it takes a 12,000 GB annual commitment. Premium IPv6 Residential runs $6/GB pay as you go down to $3.90/GB at 1,000 GB; we could not slice its annual block cleanly from the page markup, so apply the 20% rule and check the page rather than trusting a number from us.

Shared datacenter, the class that actually competes with SparkProxy:

Two traps live in those ladders, and both are about forecast error rather than rate.

The first is rung spacing. There is no rung between 241 GB and 500 GB, so a 300 GB month buys the 500 GB plan at $1,350, an effective $4.50 per consumed gigabyte: higher than the $4.00 pay-as-you-go rate. Shared datacenter has the same shape with nothing between 150 GB and 350 GB, so a 200 GB month either stays on pay as you go at $120 or buys 350 GB at $149. Infatica does not publish whether unused gigabytes roll over or expire, and we found no statement either way on the pricing page or in the terms, so confirm before committing to a large package.

The second is the teaser rate. Infatica's homepage and location pages show "from $0.3 per GB" for residential, plus "from" figures of $1 per GB for mobile and $0.6 per GB for IPv6, and a pricing-page FAQ saying high-traffic plans "can make each gigabyte as cheap as $2; in a regular pricing plan, gigabyte would cost $7". No published plan reaches any of those numbers. The cheapest published rates are $2.60/GB residential, $4/GB mobile and $3.90/GB IPv6, all monthly, so even the FAQ's $2 sits under the $2.60 floor, and its $7 "regular" rate is nowhere on the ladder either, where the dearest residential rate is the $4.00 pay as you go. Treat all of them as custom-quote figures and ask for a quote if you need one.

Against SparkProxy's flat ladder, the honest break-even on datacenter traffic lands lower than the headline rates suggest:

Read it honestly in both directions. Below roughly 125 GB a month of datacenter traffic Infatica is cheaper on published prices, and for occasional work it is not close: a 5 GB job costs about $3 there and $75 here. The often-quoted 250 GB crossover only holds at Infatica's floor rate of $0.30/GB, which exists only on the $599 plan for 2,000 GB, so it is not available to a buyer who needs 250 GB. Above about 125 GB the flat plan stops caring how much you pull. The table compares traffic cost only: Starter is 100 concurrent threads, no shared-datacenter concurrency ceiling is published anywhere we could find, and threads and ports are different units, so do not put 100 against 1,000 and call it a result. Per-IP vs per-GB proxy pricing works the general arithmetic, and unlimited bandwidth proxies worth it covers what the flat side buys.

SparkProxy's published ladder, for the same comparison:

Annual is 15% off the monthly rate, bandwidth is unlimited on every tier with no caps or overage fees, and the current page shows promo code SPARK20 for 20% off a first month. Pricing lives on the homepage at sparkproxy.io/#pricing; there is no separate pricing page.

One more way to buy depth, which SparkProxy does not offer at all: Infatica's per-IP products. Static ISP runs "From $1.95 to $3.00" per IP per month and Dedicated Datacenter "From $1 to $1.50", both with unlimited traffic and both with minimum commitment shown only as custom or upon request, so the real minimum is a conversation rather than a published number. Fifty dedicated addresses at $1 to $1.50 is $50 to $75 a month for an effective depth of exactly fifty, known without measuring anything. A per-IP product is the only way to buy depth you can count.

On terms, neither vendor is the lenient one. Infatica's refund policy excludes ISP and datacenter proxies outright, provided "on an 'as-is' basis, and we do not offer refunds", and bars refunds more than 10 days after payment, under $5, or once a trial has started; its terms state access "will auto-renew for the next month and the service fee will be debited automatically upfront". SparkProxy's policy is that "All payments made for SparkProxy paid plans are final and non-refundable", with no pro-rata refunds and the 24-hour free trial as the evaluation mechanism. Proxy free trials and refund policies compared has the wider survey.

Not a courtesy section. These are workloads where we would tell you to buy Infatica.

• Residential, mobile, ISP or IPv6-residential exits at proxy-plan volume. SparkProxy sells no standalone plan in any of those four classes. The one residential path we have is the metered Scraping API add-on described above, at ten times the credit cost of a plain fetch per request, which suits spot checks rather than a crawl. Account-bound work, mobile-app traffic, carrier-ASN targets and consumer sites that reject datacenter ranges belong on Infatica.
• Low-volume, one-off and spiky jobs. Pay as you go makes a 5 GB residential scrape about $20 at $4/GB and a 5 GB datacenter job about $3 at $0.60/GB, with no subscription. SparkProxy's floor is $75 a month whether you pull 1 GB or 10 TB.
• Fine-grained geo and device targeting. Country, subdivision, city, ZIP, ISP ID, ASN and operating system are documented as username parameters that combine in one request, for example xxx_c_US_city_New-York_asn_12271_s_100. If the job needs a specific metro, ASN or device OS, there is no SparkProxy equivalent.
• Per-session IP control with an explicit TTL. Arbitrary session IDs, _ttl_10s through _ttl_1h, a documented 60-minute inactive-session limit, and three exit-node failover modes, which the docs define as what happens when no exit node is available rather than as a rotation cadence (_rotm_0 instant retry, _rotm_1 a five-second delay, _rotm_2 no switch at all) and require be combined with _s_ and/or _ttl_. SparkProxy publishes random rotation and 5-minute auto-rotation. Checkout flows and multi-step logins belong on Infatica.
• Compliance-gated procurement. Four active ISO certifications with the certificates themselves downloadable from the Trust Center, all four issued to INFATICA LTD: ISO/IEC 27001:2022 (certificate GB21905E), ISO/IEC 27701:2019 (GB63441V), ISO 22301:2019 (GB63441L) and ISO/IEC 20000-1:2018 (GB63441F), each number read off the PDF itself on 9 October 2026. Add mandatory KYC and two named third-party SDK security audits (Halborn, July 2025; NCC Group, October 2025). SOC 2 Type 2 is described as "currently in scope and on the compliance roadmap", so not held today. SparkProxy publishes no equivalent paperwork.
• Buyers who need a per-country figure before committing. Exact residential counts for 11 countries and 107 country pages, against zero per-country counts from us.
• Static dedicated IPs with unlimited traffic. Static ISP from $1.95 to $3.00 per IP per month, Dedicated Datacenter from $1 to $1.50. SparkProxy prices rotating plans by thread count, so long-lived pinned identities are an Infatica product.
• A long unpaid evaluation of a managed scraper. Infatica's Web Scraper API trial is 7 days with "No credit card required. Pay only after 5,000 successful requests." SparkProxy's 1,000 credits is 200 JS-rendered calls at 5 credits each. The reverse holds on proxies: Infatica's proxy trials are paid, $3 to $8 for 7 days and 1 GB, and KYC-gated, while SparkProxy's 24-hour 250-thread proxy trial is free with no card.
• High-volume per-request scraping without JS rendering. Infatica's Basic Web Scraper API reaches $0.08 per 1,000 requests at $1,776 a month for 22.2M requests, with JSON parsing, DC proxy and US and EU geo-targeting; JS rendering and residential proxy are Pro-tier only, from $0.78 per 1,000 down to $0.63. That Basic unit cost is very low and we publish no comparable per-request floor at that scale.
• Teams that need traffic forensics from the dashboard. Daily, weekly and monthly traffic statistics, a "Top Targets" view of the most frequently accessed target hosts, and a date-ranged "Traffic Logs Export" delivered by email. For chargeback, per-project attribution or chasing a runaway crawler that export is worth real money, and SparkProxy documents nothing like it.

On sourcing we quote Infatica and stop there. Its Trust Center states "All residential IPs in the Infatica network originate from users who have explicitly agreed to participate", that "Participation requires a clear opt-in process. Users must provide consent before their device becomes part of the network", and describes the mechanism as developers integrating "the Infatica SDK into their applications" so that "application users can choose to participate by sharing a portion of their device's idle bandwidth". Its product pages call the network "Peer-to-business" and "100% ethically-sourced". Those are the vendor's own published words. The two named audits are described as SDK security audits, which is not an audit of consent collection, and we will not characterise either beyond that. Where do residential proxy IPs come from covers the category rather than any one vendor.

• Targets that accept a datacenter exit and tolerate a generous per-address request budget. That combination is the one where depth stops being the binding constraint: if a target will take forty requests an hour from one address, the measured depth you need drops by a factor of eight against a target that tolerates five, and a 1M+ datacenter pool clears it in any country you pin. Where a datacenter exit works at all, residential rates buy you nothing but a per-gigabyte meter.
• Traffic you cannot forecast. Unlimited bandwidth on every plan means a retry storm, a 4 MB page that was 400 KB last month, or a crawl that doubles mid-month all cost what a quiet month costs. On a per-gigabyte meter the forecast error is the bill.
• Above roughly 125 GB a month of datacenter traffic, where the flat $75 plan has already won on the table above and keeps winning as volume climbs.
• Retry-heavy work against hostile targets, where the ban tax is paid in time rather than in metered gigabytes.
• Evaluation with no card and no identity check. 24 hours, 250 threads, USA and worldwide, plus 1,000 Scraping API credits.
• HTTPS or SOCKS5 without a stated performance caveat. Infatica's docs recommend HTTP and SOCKS5 and say HTTPS "is also available but is not recommended for performance-sensitive tasks". SparkProxy lists all three with no such note. Infatica's docs also warn that IP whitelists "have priority over regular proxy lists, which causes incompatibility between requests from different lists", a real footgun if you mix auth modes.
• A managed scrape with content conversion built in. One endpoint, X-API-Key auth, format for html, md, mdx, json, screenshot or pdf, js_scenario for browser actions, extract_rules for structured output (documented as requiring render_js=true, so it carries the 5-credit rendering cost rather than the 1-credit plain fetch), and batch mode where the whole batch costs 1 credit with render_js=false.

And the limits, plainly, because the wrong purchase here is an expensive one: no standalone residential, mobile, ISP or IPv6 proxy plans, with residential exits available only as a metered Scraping API add-on; no per-country IP counts published; no city, ZIP, subdivision, ISP, ASN or device-OS targeting; no documented session TTL or exit-failover mode beyond random and 5-minute auto-rotation; no published ISO certifications; no traffic-log export. Two or more of those on your requirements list means Infatica, not us.