How we test proxies
This page describes everything Caiman Check does: which requests are sent, what counts as success, how each number in the report is calculated, and where the method has limits. The goal is that anyone can understand the report and, if they wish, repeat the test themselves.
Methodology version: v1.12.4, November 2026. A report shows the measurement version it was made with: v1.10 measurements are current; later versions changed the comparison rules and “My site” mode. See Changes.
1. Principles
- Same conditions. A and B requests are interleaved, at the same time, to the same sites, with the same settings.
- No retries. Each request is made once on a fresh connection. Failed requests are not retried: retries would hide the real error rate.
- Honest margin of error. Percentages come with a margin. If the difference is within it, the report calls the providers roughly equal.
- Only shared parameters in scores. Overall scores use only what was measured for both providers.
- Everything visible. All metrics are in the report. The scenario changes only the order.
2. How a test runs
- Line check. Each of the first 10 lines makes a request to our service address, which returns the caller's IP. If the exit did not answer, the connection dropped or timed out, we make up to 5 tries with a 1.5 s pause: a residential exit (someone's home device) can vanish for a few seconds, and a provider may need time to assign an exit to a new session. A line counts as not answering only after 5 failures, and the result shows on which try it answered. A wrong login, a provider block and a proxy that does not answer at all are not retried, since they do not clear by themselves. This is the pre-test check; in the test itself every line also gets at least 3 requests to different sites. From it: we see whether the line works, its exit IP, country, network and system. The protocol (SOCKS5 or HTTP) is detected automatically.
- Control requests without a proxy. Each site is opened once directly from our server. Sites that don't respond at all (network, DNS) are excluded. Sites that answer with a block or captcha stay in: that's where proxies differ.
- Main test. The chosen number of requests per provider, 12 at a time for each (24 for tests from 600 requests), in separate queues so a slow provider doesn't take threads from the other. Lines are used in turn, each getting an equal share; with many lines there are at least 3 requests per line (up to 1000 lines per provider). Sites are spread evenly, and one line's requests go to different sites. A's i-th and B's i-th request go to the same site. Timeout per request: 15 seconds.
- Requests look like a browser. A library reproduces a real browser's TLS and HTTP/2 fingerprint (current Chrome; Safari for iOS). The OS in the User-Agent matches the profile chosen for the test. The client used is shown in the report.
- Not a full browser. JavaScript is not executed and cookies are not kept between requests, so “success” is success for an HTTP client: a real browser may pass checks an HTTP client stops at (e.g. JavaScript challenges), and vice versa. Conditions are equal for A and B, but absolute percentages for browser work will differ.
- Extra checks in parallel. Some requests also hit our service address to learn exit IP, country, city, network and system. Up to 20 lines: every fifth round over all lines. From 20 lines: each line once, and the first 10 lines a second time to see whether a line keeps its IP. UDP is tested on every line of the list (see UDP).
- Load mode (optional): requests are split into 3 equal steps of 10, 40 and 100 concurrent requests per provider. We watch our server's CPU during each step: at 85% or more the step is limited by us, not the proxy, and is excluded from the comparison.
Site sets per scenario. Scraping: Amazon, eBay, Walmart and Etsy search, Booking hotel search, Bing results, a Wikipedia article. Before antidetect: sign-up pages of Facebook, Instagram, TikTok, Google, Reddit, Discord, eBay, LinkedIn. General: home pages of popular sites plus Bing and DuckDuckGo results.
This is the default list. The service administrator can add sites of their own and switch off or delete any of them, the default ones included. The list applies to new tests; every report shows in its “By site” table which sites it was measured on, and finished reports keep their set. For an added site the success marker is one of two: “the page opens” (no block, captcha or error, a response of at least 500 bytes) or “the page contains the given text”.
Content check. Status 200 doesn't mean the right page arrived: a site may return a login wall, a stub or an “enable JavaScript” page. Each site has a marker of the expected page; without it the request fails as “wrong page”. If neither provider ever got the expected page from a site, the site probably changed: it is excluded from totals and the report says so. Google search is not used: it requires JavaScript and returns no results without a browser.
You can test your own sites instead: see “My site”.
Which proxies we test and the pre-run check
Caiman Check tests residential and mobile proxies. You pick the type at the top of the form: mobile is compared with mobile, residential with residential. Before the run every line goes through a trial check that doesn't count against your limit:
- Lines. One request through each of the first 10 lines: does it work, protocol, IP, country, network.
- Rotation. 6 requests in a row through the first line: does the IP change.
- Login. If the login explicitly sets a country, region, city, ISP, system or session (e.g.
country-de,session-abc), we show it and compare it with the actual exits. If we don't know the login format, we claim nothing. - Gateway. The country of the address we connect to and the TCP connect time to it from our server (best of three). It's shown in the report because speed also depends on the distance to the gateway.
The result is a green, yellow or red verdict. Red stops the run for free accounts, because such a test would show nothing:
- 60% or more of the exit IPs (out of at least 3) belong to hosting providers: these are datacenter proxies.
- For pool estimation: the IP doesn't change over 6 requests in a row, or the login sets a sticky session. Sticky sessions are fine for comparisons.
Yellow doesn't stop the run, it warns: some IPs are hosting, the exit country differs from the ordered one, rotation isn't per request, no mobile carriers seen for the “Mobile” type. The network type comes from the network name and number (ASN), so mobile carriers aren't always recognized.
3. What counts as success
A request succeeds if the site returned a normal page: status 2xx or 3xx and not a verification page. 403, 429 and 503 count as a site block. Redirects are followed like a browser (up to 20, as in Chrome). In “My site” mode, at most 5, each checked against the block list.
Verification pages are recognised only by precise markers of those pages, not by single words: normal pages also contain “recaptcha” or Cloudflare's service script, and that is not a block. Markers: Cloudflare response header cf-mitigated: challenge, cf_chl_opt, cf-chl-widget, title “Just a moment...”; Google /sorry/, “unusual traffic”; Amazon /errors/validateCaptcha; DataDome captcha-delivery.com; PerimeterX px-captcha; Akamai title “Access Denied”, errors.edgesuite.net; Reddit “whoa there, pardner”; AWS WAF AwsWafIntegration.
4. Error causes
| Report category | What happened technically |
|---|---|
| Wrong proxy login or password | SOCKS5 rejected auth, or HTTP proxy returned 407 |
| Proxy server not responding | Couldn't connect to the proxy itself (curl 5, 7) |
| Provider blocks this site | SOCKS5 reply code 2 "not allowed by ruleset", or HTTP CONNECT 403/451 |
| Exit IP couldn't reach the site | Proxy accepted, but the exit device failed to connect: SOCKS5 codes 1, 3, 4, 5, 6 or CONNECT 5xx |
| Couldn't connect within 15 seconds | curl 28 “Connection timed out” |
| Full answer took over 15 seconds | curl 28 “Operation timed out” |
| Site certificate failed verification | curl 60: through a proxy, a possible sign of traffic interception |
| Secure connection error | TLS handshake failure (curl 35, 58, 59, 83); through a proxy often a channel dropped mid-handshake |
| Connection dropped | Connection closed mid-response |
| Site blocked it | Captcha, 403, 429 or 503 from the site |
| Site returned an error | Other 4xx and 5xx from the site |
5. Metrics
Requests that went through
Share of successful requests. The ± is a 95% Wilson confidence interval: with 100 requests and 90% success it's about ±6 points.
Price of 1,000 GB of useful traffic
Formula: price per GB × 1000 × all traffic / traffic of successful requests.
Traffic is counted as the provider sees it: bytes actually received over the network before decompression, plus response headers, request size and an estimated 6 KB TLS handshake per new HTTPS connection. For failed requests we count what arrived before the failure. The provider's meter may differ by 5–15% due to service packets, equally for A and B.
Price of 1,000 successful requests
Formula: price per GB × all traffic in GB / successful requests × 1000. A provider more expensive per GB can be cheaper per result.
Response time
Compared only on sites where both got through (at least 5 successes each): the median per site, then the mean across sites weighted by min(A successes, B successes), the same weights for both. Otherwise a provider let onto only easy, fast sites would look faster. A gap counts if it exceeds 0.2 s and its 95% bootstrap interval (per site, corrected for repeating exits) excludes zero. Time from request start to the full answer, successful requests only, taken from the network library's counter rather than our program's clock, so load on our server doesn't distort proxy speed. Median (mean of the two middle values for even counts) and 90th percentile (nearest-rank method).
Time is split into phases: connecting to the proxy (entry server, relay), proxy opening the channel to the site (exit device connecting, including TLS), site response (to first byte), page download and redirects. A slow proxy connection is usually fixed by another relay; a slow channel depends on exit devices.
UDP
- We connect to the proxy via SOCKS5 and request a UDP channel (
UDP ASSOCIATE). - We send packets with a unique random tag to our server on ports 3478, 19302 and 8443 (STUN/WebRTC ports).
- Our server records which tags it received and from which IP, and replies in its own format.
- "Works" is counted only if the reply is in our format and our server confirms it received that tag. A proxy that bounces the packet back is detected and shown separately.
UDP is tested via SOCKS5 only; HTTP proxies have no UDP. If lines are HTTP, UDP is "not checked" and excluded from scores for both.
How many lines. UDP is tested on every line of the list: 20 lines get 20 checks, 1,000 lines get 1,000. There is no sample, so no sampling error: the report shows how many lines of your list pass UDP. The checks run alongside the main test (up to 40 at once); if they finish later, the test page shows how many lines are left. If the test hits its time limit (1 hour), unchecked lines are not counted and the checked ones remain a random sample. Each line gets up to 3 tries with a 1.5 s pause: UDP on residential exits can drop out for a moment, like an ordinary connection. If a line turned out dead in the test itself (no successful request), its UDP is not counted; otherwise dead lines would pull UDP down and the readiness score would penalise them twice. The number of lines excluded this way is shown next to the result. On a small sample 4/5 vs 2/5 is chance: a UDP win needs a significant gap (for example 5/5 vs 0/5).
System match with profile
We inspect the first TCP packet from the exit device on our server, as antifraud systems do (passive OS fingerprinting, p0f).
| Signal | Windows | Linux / Android | macOS / iOS |
|---|---|---|---|
| Initial TTL | 128 | 64 | 64 |
| TCP option order | MSS, NOP, WS, NOP, NOP, SACK | MSS, SACK, TS, NOP, WS | MSS, NOP, WS, NOP, NOP, TS, SACK, EOL |
Limits: 3 families, not versions; Android and a Linux server look the same. MSS below 1400 often means a tunnel, VPN or mobile network.
Proxy DNS path
An attempt: through the proxy we open a unique name like a7f3k2….dns.caimancheck.com (new for every attempt, plain HTTP, no retries). The zone is delegated to our DNS server, so whoever resolves the name for the proxy has to ask us. Two observations per attempt:
- DNS query source: the IP our DNS saw for this label. It can be a public resolver, a forwarder or provider infrastructure: it's the source of the query to our zone, not necessarily “the device's resolver”.
- Exit IP: seen by our web server. “Site answered” counts only if the answer came from our server with the same name and label. A proxy or block page doesn't count.
The source's category relative to the exit (rules checked in this order):
- In the exit IP's network: same network number (ASN) and the exit isn't hosting. If it's also a public DNS network, the details show both. It doesn't prove where the resolver physically ran.
- Public DNS: a known Google, Cloudflare, Quad9, OpenDNS or Yandex network, or a public DNS network name.
- DNS in a datacenter: a hosting network by number or name. Exit and source in the same hosting (e.g. both OVH) go here.
- Network unknown: the source network isn't in the database or the exit network is unknown. No confident conclusion.
- Another network: everything else. Some ISPs run DNS in a separate network.
If sources of different categories asked for the label, the attempt is “several categories”, and the categories seen are listed. The order of arrival doesn't affect the result; repeated queries from the same address aren't counted twice.
Collection window. After the site answers we wait at least 1 second, plus 0.5 seconds after the last new event, but no more than 3 seconds. The report shows how many attempts got events after the site answered and how late, so the window can be checked.
Denominators. The counter “planned · done · reached the site · DNS seen” and shares “k of n” of attempts with both an exit and a DNS event. Next to the result there's always “DNS seen in X of Y attempts”, so providers with different coverage can't be confused. Separately: “site answered, no DNS”, “DNS, site didn't answer” and why attempts didn't reach the site.
By exit. Share by attempts and share by exits answer different questions, so both are shown: exits by their most common category, and how many exits with 2+ observations changed category between attempts.
Control of our own path. Before, every minute during and after the test the server resolves a unique name through the public delegation and checks the event reached the report store. Path 1: the server's DNS; if that fails, path 2: public resolvers directly (so a fault of the server's own DNS isn't taken for a zone fault). If a control fails, the report shows the failure interval by the times of neighbouring controls, and attempts without DNS inside it aren't counted against the provider. If no control passed after the start, the measurement is marked partial: only confirmed observations are shown.
Is this a DNS leak? The service records only the observation: which source asked our zone and its network and geo-database country relative to the exit. Whether that's a leak for you depends on the DNS path you expect (e.g. the device ISP's DNS). Country is compared only for non-public sources: public ones use anycast.
Details (no IPs): exit network, source networks, the basis of the category, query types (A, AAAA), transport (UDP/TCP) and which IP family the source used to reach our DNS (not the record type). Identical attempts are folded with a ×N counter; attempts with any difference are separate rows. The rules version and geo database date go into the report. Up to 30 attempts per provider. Source and exit IPs aren't stored. DNS isn't part of the readiness score yet.
IP diversity
Different exit IPs across exit probes. More is better for rotation; one IP per sticky line is normal. Rotation vs sticky is detected from repeated probes of the same line: if the IP stays the same on 70% of such lines, it is sticky or static.
Working lines
Shown when a provider has more than one line. Each line gets at least 3 requests to different sites plus one check request to our service address (it has no bot protection). A line is working if at least one request succeeded: to a site or the check one. It is stable if all requests to sites succeeded. If no request to a site succeeded but the check request did, the line counts as working with interruptions: the proxy connects and reaches the network, while sites answered with a block or an error. Lines where nothing succeeded, the check request included, are listed by number with the main reason, ready to send to the provider for replacement. Lines whose exit is outside the ordered country or in a hosting network are listed too (one exit probe per line). A difference in the working share counts as a win only if it is statistically significant.
Answers from a site where nobody had a success (with at least 6 requests to the site across all sides) are not counted against a line: if a site answers everyone that way, it is the site's answer, not a line problem. Such sites are listed under the copy buttons. A line through which no request finished gets a separate “unchecked” status and is not counted as dead.
Limitation: 3 requests to sites is little for one line, and a site blocking an IP is not a broken proxy. That is why the check request to our address is counted and dead lines show the main error reason. A line with no response here may still work by hand for you, for instance if it cannot reach our check address or port. Send the report number and we will look.
Country and city
Free DB-IP Lite databases, updated monthly. Their accuracy is not guaranteed: usually reliable for country, noticeably worse for city, especially on mobile networks. Same database for A and B.
Hosting IPs and networks (ASN)
Each exit IP's network is classified as hosting (known cloud/hosting ASNs or names with host, cloud, server, datacenter, vps…), likely mobile (mobile, wireless, cellular or a mobile operator's name) or home ISP (everything else). A heuristic: accurate for big clouds, small regional networks may be misclassified.
Behaviour under load
Same requests at 10, 40 and 100 concurrent per provider; success and median time per step.
6. Antidetect readiness
| Parameter | Weight | Input |
|---|---|---|
| System match | 35 | % of connections with the chosen system |
| UDP via proxy | 25 | share of lines with confirmed UDP |
| No hosting / data-centre IPs | 25 | 100% minus their share |
| Country match | 15 | % of exits in the promised country |
A score is given only if at least 3 of the 4 parameters are measured; the parts it is made of are always shown next to it.
Where the weights come from. They are an expert judgement, not a measurement: they reflect how often each signal gets an account blocked in an antidetect browser. A system mismatch is visible to the site on every connection, so it weighs most; UDP and hosting IPs give a proxy away less often on their own; country is most often fixed by settings. A readiness win counts only if every significant difference between the parts favours the same provider, so the weights cannot pull the verdict against a tested difference. Each of the four checks is shown in the report separately with its own result, and you can decide by them without looking at the single score.
A parameter missing for either provider is excluded for both and the remaining weights are rescaled proportionally (without UDP: 47 / 33 / 20). A small MSS (below 1400) is not scored: it occurs in tunnels and VPNs but also in ordinary mobile networks, whose IPs are valuable for antidetect. It is shown separately for information.
7. Key differences and scenarios
Up to 4 metrics with the largest gap, measured as a share of the metric's scale (or of the larger value for prices and time), multiplied by the scenario weight. Gaps under 10% (under 15% for price) are hidden; success gaps within the margin of error are hidden too.
The verdict at the top has two parts. “For antidetect”: the readiness score (if it differs significantly and all its significant parts favour the same provider), otherwise significant gaps in system, UDP, hosting IPs, country, city, success and working lines. Success and working lines are included because a dead line is worse for an account than any other problem. “For scraping”: success, working lines, cost per 1,000 successful requests, load and speed. With no significant gaps the verdict is “about equal”.
| Metric | Antidetect | Scraping | General |
|---|---|---|---|
| Antidetect readiness | 1.5 | 0.5 | 1 |
| System match | 1.4 | 0.5 | 1 |
| UDP | 1.4 | 0.5 | 1 |
| Hosting IPs | 1.3 | 1.0 | 1 |
| Country | 1.2 | 0.9 | 1 |
| City | 1.1 | 0.8 | 1 |
| Success | 1.0 | 1.4 | 1 |
| Price of 1,000 successful | 0.8 | 1.5 | 1 |
| Speed | 0.7 | 1.2 | 1 |
| Load | 0.6 | 1.3 | 1 |
Checking one provider
The same test without a second provider: same sites, client, exit probes, UDP and system checks. Instead of a comparison, each metric gets “good / attention / poor” by the guidelines below. These are our guidelines for residential proxies, not an industry standard; for datacenter proxies some thresholds (network type, system) don't apply.
- Successful requests: good from 90%, attention 70–89%, poor below 70%.
- Response time (median): good up to 2 s, attention up to 4 s, poor beyond.
- System matches the profile: good from 90%, attention 60–89%.
- UDP: good if it works on all tested lines; attention if on some.
- Hosting IPs: good up to 5%, attention up to 20%.
- Exit in the ordered country: good from 95%, attention 80–94%. In the ordered city: good from 80%, attention 50–79%.
- Timeouts: good up to 2%, attention up to 10%.
- Working lines (if more than one): good from 98%, attention 90–97%.
“Readiness” uses the same weights as in a comparison, over the metrics measured for this provider.
Pool size estimate
A separate mode for rotating proxies. Many requests go through one line to our service address over HTTPS (about 7 KB each) and the exit of every successful request is recorded. The provider can't fake it: our server sees the address and the response is TLS-protected. An exit is an IPv4 address or an IPv6 /64.
Quantities estimated
- Effective pool size at run time: N = 1/Σp², p being the probability of getting a given exit in this run. The number of equally loaded exits with the same repeat rate; equal to the exit count under even rotation, smaller otherwise. Estimate: n(n−1)/2C, C being request pairs with the same exit. 95% interval: Poisson for C, widened by the measured overdispersion (variance estimated from triple matches).
- Total exits at least: a lower bound only, since the total under uneven issuance can't be determined from outside (W. Link, 2003): the larger of the Chao1 lower bound (A. Chao, 1984/1987) and the effective-size lower bound. Under a no-reuse window Chao1 isn't used: it overestimated in calibration.
- Issuance similarity between runs: Σpᵢpⱼ/√(Σpᵢ²·Σpⱼ²), 0 to 1. For even pools it's the share of common exits. Below 1 means the pool changed between runs or the accounts see different parts of it. Similarity doesn't say which is inside which: if 100 exits of one run all sit inside 400 exits of another, similarity is 0.5. So we also show containment both ways: "1 inside 2: 100%, 2 inside 1: 25%".
- Effective issuance size over the period: 1/Σp̄², p̄ being issuance averaged over all runs in the series. Equals the snapshot size if the pool is stable; larger if it changed or accounts differ. The report lists the accounts included.
Corrections
- “Sticky” issuance. Repeats among simultaneous or adjacent (within 2× the thread count) requests are rare under random issuance, about 4×threads/n. If there are 5+ times more, issuance isn't random: those requests are removed entirely and the number of possible pairs is reduced by the share of natural nearby repeats, so the estimate isn't inflated.
- No-reuse window. If no repeat is closer than n/20 requests although 5+ were expected, only pairs beyond the detected window count.
- IPv6. An exit is counted per /64; the report shows unique IPv4 and /64 subnets separately and, for IPv6, how many exits there would be grouping by address, /64, /56 and /48. It also states whether the measuring address accepted IPv6 in this run (an AAAA record pointing to an address configured on our server). If not, the provider's IPv6 exits aren't visible.
- CGNAT. The mobile share comes from the provider (ASN) database and doesn't measure CGNAT: how many subscribers share an IP can't be learned from requests to our address (on CGNAT deployment and how it's measured: Richter et al., IMC 2016). The CGNAT note is shown at 30%+ mobile IPs; that's a display rule, not a measurement.
Calibration
Checked on pools with known truth, 100 independent runs per scenario. Share of runs where the 95% interval contains the truth:
- 1M exits, 20,000 requests: even 94% (48 threads) and 99% (sequential); 30% of load on 10% of exits 99%; log-normal load 99%.
- “Sticky” neighbours 2% and 10%: 94–96%, median within 2% of the truth; parallel and sequential runs give the same result, so removing matches doesn't inflate the estimate. Without stickiness the correction never fired in 100 runs.
- No-reuse window of 3000 requests: 96%, median −1.3%.
- 15M exits, 55,000 requests: even 95% (median 14.9M), uneven 99% (8.36M vs a true 8.29M).
- Two runs: stable pool — similarity 0.99, coverage 98%; 30% of exits replaced — similarity 0.70 vs a true 0.70, coverage 94–95%; two accounts each seeing half the pool — 0.50 vs a true 0.50, coverage 97%; period size: coverage 97–98%.
- “Total exits at least” was not above the truth in 95–100% of runs (it is a 95%-level bound), including under a no-reuse window (98%).
Under uneven issuance the intervals are conservative (99% instead of 95%), i.e. rather wider than needed. The calibration script is part of the source (tools/calibrate.py) and results are reproducible.
What can't be known from outside
How many devices are behind one IP, how many exits the provider gives other customers, and how many the pool had on other days. Provider figures like “15M IPs” usually count all IPs over a month; the closest thing is the period issuance size from a series of runs at different times of day.
How many requests: about √(200·N) for ~100 matches: about 15,000 for 1M exits (≈100 MB), about 55,000 for 15M (≈380 MB, 20–30 minutes).
My site
You can test providers on your own addresses instead of our site set: 1 to 3 pages. All test requests go to these pages and only through your proxies; our server never contacts your site directly.
- Gentle on the site: ordinary GET requests only, at most 4 at a time per provider and at most 30 requests per line, load mode off. A page over 3 MB is cut off. One domain is tested at most 5 times per 10 minutes by all users together.
- Public pages only: the test sends no cookies and never gets into an account. An address with a login and password inside is not accepted.
- What can't be tested: banks, payment systems, government sites, internal and hidden addresses, an IP instead of a site name, ports other than the usual 80 and 443. We follow redirects (at most 5) ourselves and check every address against the same list; a redirect to a blocked address counts as the site's answer, not a proxy fault. Crypto exchanges are allowed.
- What counts as a failure: the same as on our site set (captcha, check page, 403, connection errors), plus an empty or too-short page (under 500 bytes; a JSON answer counts at any length) and a page without the text you entered for that address. A 429 answer is shown as its own cause, “the site limited the rate”: that is the site reacting to the test, not provider quality. We don't know in advance how your site shows a block: if it returns a normal-looking page with code 200, enter text that only the right page contains.
- Trial before the test: as soon as an address is entered and the proxies are checked, we open the page in the background through 3 lines of each provider and show the title, size and what each got. The right page's title is filled into the text field as a marker (marked as such; you can trim it to the part that doesn't change). The marker is compared with the page text after decoding HTML entities and collapsing spaces; a JSON answer is checked to parse as JSON. If every trial for both hits a check page, we warn before the run; if you run anyway and check pages make up half or more of the requests for both, there is no verdict. Trials return only the title and size and don't count toward the test limit. Traffic is counted in bytes that went through the proxy, and for HTML only.
- What the site returned: the report shows the most frequent page titles for each provider and redirects to another domain (for example amazon.com → amazon.de). This shows the truth even without the text.
- When there is no verdict: if both providers got under 15% successes and the causes are on the site's side (almost all check pages, the site not answering or limiting the rate), the report says so and names no winner. If this happens with only some addresses, they are excluded from the totals and stay in the per-site table.
- Comparison and winner use the same tests as on the site set, and the verdict reads “on your sites … is better”: by success, working lines, cost per successful request and speed, without the “antidetect” and “scraping” scenarios. IP properties (network type, country, system, UDP) are checked as usual.
- Privacy: the report keeps only the domain, no path or parameters. A public link shows “Site 1”, “Site 2” instead of domains until the report owner turns them on.
8. What the test doesn't check
- Browser fingerprint (canvas, WebGL, fonts, timezone): that's the antidetect browser's job.
- Real WebRTC leaks in a specific browser: we test whether the proxy can carry UDP.
- Availability history: the test shows the state at test time.
- IP reputation in paid antifraud databases.
- IPv6: our service address is IPv4-only, so system, country and network describe IPv4 exits; sites may receive IPv6 from exits that support it.
- Probes and site requests are different connections: with rotation, system/country/network describe a sample of the pool, not the same exits.
- Small samples: with 50–100 requests a few points of difference may be chance.
- Residential pools change: a repeat test may differ.
When a comparison is unreliable
- Few distinct devices. With fewer than 8 different exit IPs (e.g. one sticky line), 100 requests are effectively a few devices. The report warns and doesn't count a success difference as a win.
- Repeating exits. Requests through the same exit aren't independent: a good or bad exit carries dozens of answers. If exit probes see repeats (distinct IPs under 80% of probes), the sample used by the test is shrunk by 1 + (m − 1) × 0.1, where m is requests per exit, and the difference interval gets wider. In the A/A simulation without this correction, 10–50 exits gave 11–30% false wins; with it they stay around 5% or below. The price of honesty: with a small pool a bigger difference is needed to count.
- Lines of a list. Requests through one line depend on each other too: a dead line fails all its requests at once, and a good line carries its successes. So for lists of several lines the report estimates from the data how alike the requests of one line are (intraclass correlation, ANOVA estimate over both providers' lines) and shrinks the sample by 1 + (m − 1) × ρ, where m is requests per line. Without this correction, on two identical lists of 20 lines with 10–25% dead lines a false success winner appeared in 12–19% of runs; with it, in 1–4%. As a result, for a list of static lines precision depends on the number of lines, not requests; the new-test form shows what gap the test can notice.
- Different modes. If one provider is sticky and the other rotates, IP diversity is not compared. The mode is detected automatically from IP repeats.
- Different setup. Before the run the site warns if A and B differ in protocol, country or number of lines. The report shows “How the proxies are set up” so anyone can repeat the test.
- A single run. “Repeat with the same settings” builds a series; the series page shows in how many of N runs each provider was better on each metric.
- Significance. A difference in a share (success, system, country, city, hosting IPs, load, UDP) counts as a win only if it is significant at 95% by Fisher's exact test. It stays correct on small numbers: 5/5 vs 2/5 and UDP 5/5 vs 4/5 are “not enough data”, not a win. For success the difference must also hold within sites (Cochran–Mantel–Haenszel test, each site separately), so one “hard” site can't create a false win. The success row shows the difference in percentage points with its 95% interval. For system, country, city and hosting IPs significance is counted by distinct IPs, not probes: a repeat probe of the same IP is not new data; with fewer than 8 distinct IPs there is no verdict. Price and speed are compared only when each provider has at least 30 successful requests; a price gap under 15% is a tie, because the provider's own counter differs from ours by 5–15%. The readiness score gives a win only if at least one of its parts differs significantly and every significant part favours the same provider. Speed counts as a win only if the 95% bootstrap interval of the median difference excludes zero (corrected for repeating exits) and the gap is at least 0.2 s. Pool size is compared by the effective-size estimate with its 95% interval, not by the number of IPs seen: that number grows with successful probes, so a provider blocked less often would look “bigger”. Network diversity is shown for information, with no winner. Secondary metrics (system, hosting IPs, country, city, UDP, working lines, load) are tested with a Holm correction for their number; otherwise with seven metrics one would “win” by chance. The false-win rate is checked by simulating two identical providers (A/A) through the same code that builds the report: at most 4% per summary row, and the verdict names a winner in 3–6% of cases (measured on 800 runs, 6 scenarios including lists with dead lines; see v1.11). The same simulation checks that real differences show: with a large pool, a B that is 1.6× slower, has 35% hosting IPs and 10 points lower success is called worse in 80–100% of runs. Both checks are part of the server self-test and block a release that fails them.
- Server location. Tests run from our server in Europe. Speed depends on the distance to the provider's entry server (relay): European relays will be faster than American ones. Conditions are equal for A and B, but absolute seconds from the US or Asia would differ.
- Speed and timeouts. Median and 9-in-10 use successful requests, so a provider whose hard requests fail more often could look fast. So we also show the share of all requests that returned the right page within 5 seconds, and the timeout share. Speed counts as an advantage only if the faster provider has no more than 5 points more timeouts and no fewer useful answers within 5 seconds (2-point tolerance).
- Excluded sites. In a comparison a site is excluded from the totals if it tells providers nothing: either no provider ever got the right page and most answers were “wrong page” (the site probably changed its markup), or both providers together got 2% or fewer successes with at least 20 requests each and at least 60% of the failures were on the site's side (a check page, a refusal or the wrong page). Such a site blocks this kind of client for everyone; kept in, it only lowers both rates and makes every line look unstable. An excluded site stays in the per-site table with its raw numbers, and the report also shows success over the original set. A single-provider test excludes nothing this way: with one provider a site's block and a proxy fault can't be told apart.
- 503 and “My site”. A 503 counts as a site block only with protection signs (a challenge page, Cloudflare, Akamai, DataDome or AWS WAF headers); otherwise it's a site error. For “My site” you can enter text that must be on the right page, so a 200 placeholder or a redirect to a login page doesn't count as success.
- Price is an estimate. Traffic is what our server sees (body, headers and a handshake estimate). Provider billing may differ; the rules are the same for A and B, but check absolute dollars against your dashboard.
9. Privacy
- Proxy credentials are used only during the test and exist only in the program's memory while it runs. They are never written to the database, files or logs.
- A report is visible only to the person who ran the test. Reports and PDFs contain no credentials.
- Proxies with an internal-network address (localhost, 10.x, 192.168.x, etc.) are not tested: each line's address is checked before the test and connections go only to the checked public IPs.
- Exit IPs are not stored. Reports contain only aggregates and line numbers. In “Pool size” mode, IP hashes (HMAC) are kept for 48 hours to combine runs, then deleted.
- Provider names in a report are entered by the test author.
10. Data sources
- Country, city and networks: DB-IP Lite (db-ip.com), CC BY 4.0.
- System fingerprint: our own TCP packet analysis.
- UDP: our own server on ports 3478, 19302, 8443.
Changes
v1.12.4 (17 Nov 2026). In a comparison a site that let almost no one in (≤2% successes for both together with ≥20 requests each, failures mostly on the site's side) is excluded from the totals and no longer makes lines look unstable: before, one such site (DuckDuckGo with 1 success in 250 requests) produced “every line works intermittently”. Site names are translated in the English version. The report header shows the current methodology version.
v1.12.3 (17 Nov 2026). Comparison rules unchanged. Free limit is 60 lines per provider instead of 20: with 20 lines the test noticed a success gap only from ~14 points, with 60 from ~9. The method header takes its version from the changelog; the false-win rate comes from one measurement everywhere (summary row ≤4%, verdict 3–6%). Network type is described more modestly: obvious hosting networks by number and name. The “Antidetect and accounts” scenario is now “Before antidetect”: the test checks proxies, not the browser. Under the verdict it says it is a snapshot at test time from Europe; next to cost, the price per GB the user entered is shown.
v1.12.2 (16 Nov 2026). “My site”: a background trial of the page before the test (3 lines of each provider), the title filled in as a marker, the marker compared with decoded text, JSON checked for validity, a “browser only” warning before the run.
v1.12.1 (16 Nov 2026). “My site”: its own text for each address; at most 30 requests per line; 429 as a separate cause; a JSON answer counts at any length; page titles and redirects to another domain in the report; no verdict if the site only lets a browser in, is down or limits the rate for both; the verdict is “on your sites”, without scenarios. Details in the “My site” section.
v1.12 (16 Nov 2026). “My site” mode is open to everyone: 1 to 3 of your own addresses, only through the client's proxies, at most 4 requests at a time, no load. Banks, payment systems and government sites are blocked, including via redirects. A page shorter than 500 bytes also counts as a failure. The report keeps only the domain, and a public link hides it. Details in the “My site” section. Comparison rules and thresholds did not change.
v1.11 (16 Nov 2026). Found by an outside review and confirmed by an A/A simulation. In lists of static lines, hundreds of failures from two or three dead lines were counted as independent: on identical lists of 20 lines a false success winner appeared in 12–19% of runs and in up to 20% of verdicts. Significance now accounts for requests of one line depending on each other (see “Lines of a list”). Speed is compared only on sites where both got through: before, a provider kept off slow sites looked faster. Lists with dead lines are now part of the A/A check. Measured on 800 runs, 6 scenarios (rotation with 12 and 40 exits, lists of 10, 20 and 50 lines with 10–25% dead): a false win in any single summary row at most 4%, a false verdict 3–6%. Cost per 1,000 successful requests got its own explanation (it showed the one for 1,000 GB). The new-test form shows traffic per provider and what gap the test can notice.
v1.10, comparison rules (15 Nov 2026). Found by an A/A simulation of the whole report. Price in the summary table “won” on any gap, even a cent: now a gap under 15% is a tie, with one rule for the table, the main differences and the verdict. Probe-based shares (system, country, city, hosting IPs) were tested as if each probe were a new IP, which with 12 exits gave up to 60% false wins; significance now counts distinct IPs. The readiness score could name as better the provider the only significant difference was against; now every significant part must favour it. Speed and pool size are compared with a chance check, network diversity has no winner, secondary metrics use a Holm correction. On identical providers the verdict was wrong in 20–66% of small-pool reports; now 1–6% (on the scenarios of that time). The rules also apply to earlier reports; speed and pool size are not compared in reports made before this version (they lack the data). After the first A/A tests on live proxies (5–6 lines of one provider): success under load now also corrects for repeating exits and names no winner with few IPs (it had shown a false main difference of 86% vs 68%); the ± next to success uses the same correction (it showed ±1–3 where the honest margin was ±6–13); a price gap under 15% is labelled “about equal”. The pre-test line check makes up to 5 tries instead of one: a line whose exit vanished for a second used to be marked as failing although it worked in an antidetect browser. The “for antidetect” verdict now also counts a significant gap in success and working lines: with 4 dead lines out of 20 it used to say “about equal”, since it only looked at IP quality. UDP: up to 3 tries per line, dead lines not counted. False verdict on identical providers after these changes: 1–5% (A/A, 800 runs, without dead-line scenarios; with them and after v1.11: 3–6%). UDP is tested on every line of the list instead of 5 random ones. On the report page A and B figures are no longer coloured green and red just because one is larger: colour appears only when the gap passed the chance test and the summary declares a winner.
v1.10 (14 Nov 2026). Line assessment: besides requests to sites, the check request to our service address is counted. Previously a line whose 3 requests all hit sites that block was counted as dead although the proxy might be fine; now it counts as working with interruptions. The “Copy proxies with no response” list holds only lines where nothing succeeded. The list of test sites became configurable, and the report shows which sites it used. Reports made with the previous version are marked as an older methodology.
v1.9 (November 2026). “By site” table with error causes; sites where nobody had a success are not counted against lines; an “unchecked” status for lines with no finished requests; buttons to copy lists of working, dead and unchecked lines; IP mode is shown as declared and observed, and “rotation” is no longer set without proof from a re-probe.
v1.8 (13 Nov 2026). Comparison rules after an external audit: Fisher's exact test instead of a z-test (correct on small numbers), plus a within-site check for success (Cochran–Mantel–Haenszel); the success difference in percentage points with a 95% interval; UDP on 5 lines no longer “wins” at 5/5 vs 4/5; price and speed compared from 30 successful requests each; speed takes into account the share of useful answers within 5 seconds out of all requests; the readiness score gives a win only if one of its parts differs significantly; a 503 without protection signs is a site error, not a block; “My site” accepts expected text; when a site is excluded, success over the original set is shown too; a correction for repeating exits; the “few devices” threshold raised from 5 to 8 IPs; pool series show containment both ways; the same win rules on screen, in the summary table and in the PDF. False wins on identical providers are checked by an A/A simulation. Reports made with the previous version are marked as an older methodology.
v1.7 (12 Nov 2026). The readiness score is given only when at least 3 of 4 parameters are measured (system, UDP, IP type, geo); otherwise the report says what's missing and how to measure it. Before, “100/100” could come from two parameters. New metric “Home DNS”: share of attempts where the exit IP's ISP DNS looked up the address; higher is better. Thresholds: 80%+ good, 50%+ attention.
12 Nov 2026. Proxy DNS path check: DNS query source and exit IP of the same attempt, categories with explicit denominators, control of our own path during the test. A separate metric, not part of the readiness score.
12 Nov 2026. Proxy type (residential or mobile), pre-run check with verdicts, reading settings from the login, provider gateway in the report. Metrics and scores unchanged.
12 Nov 2026, p3. Pool estimate after the audit: explicit definitions of the estimated quantities; intervals widened for overdispersion and coverage checked on series with known truth (tools/calibrate.py); “sticky” requests removed entirely without inflation; total lower bound fixed for no-reuse windows; issuance similarity between runs and account labels in a series; IPv4 and IPv6 /64 separately, IPv6 grouping sensitivity and a check that the measuring address accepts IPv6; CGNAT wording.
12 Nov 2026, p2. Pool estimate: the headline is now the effective pool size with corrections for concurrency, no-reuse windows and IPv6 (/64); total IPs shown as a lower bound; repeat runs combined; up to 100,000 requests. The comparison method is unchanged.
12 Nov 2026, p1. New “Pool size” mode.
v1.6 (11 Nov 2026). Lists of up to 1000 lines per provider with at least 3 requests per line; new “Working lines” block with numbers of dead lines, wrong-country lines and hosting lines; every line gets an exit probe; one line's requests go to different sites; rotation vs sticky detected by re-probing the same lines; UDP tested on random lines instead of the first ones; 24 threads per provider for tests from 600 requests. Security: internal-network proxy addresses are rejected and connections go only to pre-checked IPs; responses over 8 MB are truncated; a test runs at most one hour; each user sees only their own reports.
v1.5 (11 Nov 2026). TLS estimate per new connection incl. cross-site redirects; our DNS lookup excluded from “connecting to the proxy”; up to 20 redirects like Chrome; HTTP/1.1 for http:// without the non-browser h2c upgrade; connect timeout and response timeout separated; certificate verification failure shown separately as a possible interception sign; HTTPS and SOCKS4 proxies, IPv6 proxy addresses and login-only lines supported; unknown schemes no longer silently become HTTP.
v1.4 (11 Nov 2026). User-Agent OS matches the chosen profile (previously always Chrome on macOS); current Chrome fingerprint; time from the network counter; true median; our-server CPU guard in load mode; Cloudflare cf-mitigated header; RFC 1928 UDP associate with our port; small MSS no longer lowers readiness (common in mobile networks); clarified UDP and geo-accuracy wording.
v1.3 (11 Nov 2026). Scenario site sets with content checks; exclusion of sites changed for everyone; time breakdown by phase; proxy setup block and setup warnings; run series; significance testing for all shares; sticky mode detected from the number of lines.
v1.2 (11 Nov 2026). Fixed inaccuracies of v1.1:
- Verification pages are recognised by precise markers. Previously normal pages with Cloudflare's script or the word recaptcha could count as a block, understating success (equally for A and B).
- Traffic is counted before decompression, as the provider does. Previously the decompressed size was used and “price of 1,000 successful requests” was several times too high. Bytes of failed requests are now counted.
- Network type uses whole words. Previously some home ISPs (e.g. Colombian) could be labelled hosting.
- A and B have separate request queues.
- Warnings for small samples and different modes; timeouts shown next to speed.
- UDP counts only with confirmation by our server; a proxy that bounces packets back is detected.
Check your providers
Paste proxy lines; the report is ready in a few minutes.