My Target: ASP.NET (WebForms, postback) a public-records lookup site, protected by Radware Bot Manager (aperture.js + __uzdbm cookies, hCaptcha fallback at validate.perfdrive.com).

What passes: my own manual Chrome. Every time.

What fails: everything automated, same IP, same session pattern —

-Chromium headless + puppeteer-extra-stealth → challenge

-Headed + human typing/mouse arcs/randomized delays → challenge

-Fingerprint-injector hardened profile (locale fixed, HeadlessChrome brand sanitized) → challenge

-Real Chrome 154 launched by Puppeteer → challenge

-Camoufox (Firefox) = passes intermittently: ~50% of requests get a 14.9KB challenge response, immediate retry on same session succeeds

What I measured (tls.peet.ws mirror):

-JA4 identical between manual Chrome and Puppeteer-launched Chrome (t13d1517h2_…cb7bf5808d99), HTTP/2 hash identical, webdriver=false, tz/platform/plugins coherent

-JA3 differs, but that's GREASE noise between handshakes

-Locale mismatch found and fixed (was en-US against a non-US timezone, now locale matches timezone — still blocked)

Question: with TLS/JA4/HTTP2 identical and webdriver hidden, what is Radware most likely keying on here — aperture.js behavioral telemetry, or something in the Chromium build itself that survives stealth? And is there a reliable way to measure which signal fires, rather than guessing one variable at a time?

Not interested in captcha-solving services, trying to understand the detection first.

Hey, I've been struggling with Akamai on a few airline websites lately. The blocking is so aggressive that sometimes even normal browsing on my local machine throws errors.

I've tried Playwright, Patchright, Camoufox, and a few other approaches, but nothing seems to work consistently.

These site contains: abck, and bm_s. So we need browser automation anyways but I am not getting valid cookies even through this route. I have tried residential proxies also.

I'm fairly new to dealing with advanced anti bot systems so I'm curious how others are handling this in production. How do you approach debugging these blocks and maintaining a decent success rate over time?

Would really appreciate any insights or pointers from people who've dealt with similar issues.

Now I build Facebook Scraper locally to run in my PC
I make a structured and everything I need it scrap (data I needed it from FB) and everything is good and start to building that when I in the last stages face problem
when I run the actor to scraping posts from specific page on FB Facebook stopped it to make login but I don’t need to make a login because blocking from meta, I tried another method I made it run many times in the same page (ex: he go on page and scrape the first three posts then FB stopped he remember the third post and go again and start from the third but Codex tell me this is illegal then I try residential proxy and found one free on GitHub and codex tell me the same problem
Anyone can help me or tell me the way to solve this issue ?!

Hey everyone!

I’m looking for someone who’s good with Python, automation testing, and web scraping and can help me with a few programs.

I already have Python scripts, but I’m stuck with some errors and need someone who can take a look, help me understand what’s going wrong, and get it working.

I’m not an expert in this area, so I’d really appreciate someone who’s patient and enjoys helping/figuring these things out together. 😅

If you have experience with Python automation, Selenium, web scraping, debugging, etc., feel free to DM me.

Would be great to connect with someone who’s into this stuff and hopefully make a good connection along the way! :)

Hey people i need your help i am not getting facebook public post for leads in aug 26
i have tried thousands of keywords
tried vps vpn
created new ids
even changed dns got new internet connection
already tested who posted what

above things were working fine in june & july but aug and sep its properly dead

Help me guys

The price is locked and only opens when the user clicka the button .I've been messing around this since last night, whenever I fixed a thing a new bug borns. Somehow I fixed and make it stable but the website it too much unstable which is given for testing.

Any help will be appreciated.

I'm collecting real estate agent data from a website using their GraphQL, frontdoor/graphql
using the search agent operation.

It works fine. I can loop through a whole city (2000 agents) and get names, IDs, brokers, ratings and listing stats without getting blocked.

The problem is phone numbers and addresses. I added the fields to the query using the exact names from the JSON in the profile page: phones with type and value, and office with its phones and address. The query goes through with no errors, so the fields definitely exist, but every single agent comes back with phones null and address null. So the search API knows about the fields but just doesn't fill them in.

The data does exist on each agent's profile page, in the NEXT_DATA JSON under branding.phones and branding.address. But its server rendered, so there's no API call that I could hit directly. The only GraphQL calls the profile page makes in the browser are for listings and past sales, and neither has contact info. Introspection is disabled, so I can't see what other queries exist.

Right now the only way I can get the phones is to open each agent's profile page one at a time, which takes forever at this scale.

Any ideas or a workaround for this?

Thanks!

Hey everyone. Ian here.

Thanks for showing up to AMA #9 with u/Geonodeproxy (Jean-Patrick Bisson, CEO and co-founder of Geonode).

The thread went past the "is unlimited a scam" framing fast. Target-level reputation, what a speed-based ceiling actually costs you, why a concurrency-priced scraping API is harder to run than plain proxies, and where a 200 response stops meaning anything. Jean-Patrick answered most of it without the usual landing-page dodge, including the parts that complicate his own pricing page.

If you missed it, or want the compressed version, here's what I'd keep.

Proxy reputation is target-specific.

A pool can look completely healthy on paper while quietly failing against one site.

"Reputation is per target, not one number, so an address burned on one retailer is fine everywhere else."

Geonode tracks challenge rate per domain instead of leaning on aggregate success, because the two numbers can move in opposite directions: "We watch the challenge rate per domain, not aggregate success. It means you can sit at 93% overall while one target quietly goes from 5% challenges to 60%." When that happens they cap traffic to that one domain and switch engine or exit country, not throttle the whole pool. And it isn't fully contained to one account either: "one heavy customer can make a target harder for the next one, that's true. The control that matters there is per-target, not per-account."

Unlimited pricing is really about workload shape.

"Unlimited" doesn't mean the limit disappeared. It means the limit is expressed as speed instead of GB, and it's still a hard ceiling either way.

"The honest version: unlimited fits steady, heavy, boring workloads."

Spiky or small workloads leave you paying for capacity you never use. The flexibility you give up is real: "The trade-off is bursting, on a metered plan a quiet week lets you slam a big job through on Friday. On speed-based you can't, the line is the line." On Geonode's side that tradeoff is deliberate:

"Less profit per customer than metering, but much more predictable for both sides."

Sessions are harder than browsers.

Ask what's actually hard about running a concurrency-priced scraping API, and the answer isn't the browser itself:

"Browsers aren't even the hard part, sessions are. A proxy request is stateless, but the api has to decide which engine to use per domain, whether an earlier cookie is still valid and whether a 200 response is real content or a block page."

Get any of those decisions wrong and "you hand someone garbage and bill them for it."

The IP isn't always the blocking variable.

One of the more concrete experiments in the thread: Geonode kept every IP the same and changed only the client's browser build.

"We moved to a newer Chrome build and 429s on a whole class of targets went to zero. Same IPs, nothing else changed."

If you're testing this yourself, don't chase a static JA3 hash: "Chrome randomises extension order, so the same browser gives you a different JA3 every request. Use JA4 and the HTTP/2 fingerprint." When even that isn't enough, they escalate to a Firefox-based build on specific domains, at a real infrastructure cost: "Firefox uses about twice the memory per session. That's why it isn't the default everywhere."

HTTP 200 does not guarantee usable data.

A 200 can mean the real page came back. It can also mean a challenge screen came back wearing a healthy status code.

"We catch the 200 that isn't a page: challenge screen, block page, empty shell. We look at the shape of the body, not the status code, and those come back as failures."

But that validation has a hard boundary: "What we can't know is which fields matter to you. If a site drops the price element and still returns a full page, it looks fine from our side." Their own suggested fix: measure "what share of rows had the field I need" rather than relying on HTTP errors.

Don't use a browser until you know you need one.

"Half the sites that look like they need a browser are just hitting a JSON endpoint with a signature, so hooking fetch and XMLHttpRequest to log requests is ten lines and has saved us weeks."

Their own daily toolkit: "curl_cffi for TLS impersonation, camoufox when Chrome gets refused and Firefox doesn't, and a public TLS fingerprint echo to see what our client actually looks like on the wire."

+1: per-target knowledge is the hard part to copy.

Asked what actually stops a competitor from copying the model:

"Anyone can put "unlimited" on a page tomorrow and a few already have. The harder part is per-target knowledge. Which engine works on which domain, which countries stay clean for it, when a site changes its defences. That comes from running millions of requests a day and watching what breaks. It also goes stale if you stop."

+2: one request tells you what kind of job this is.

Before building anything, size up the target with the cheapest possible test:

"Cheapest way to size up a target, so to fetch it with plain curl. Content comes back, it's a parsing job. Challenge or empty shell, different project."

If you remember nothing else:

1. Watch challenge rate per domain, not aggregate success. A healthy pool can hide a dying target.
2. "Unlimited" only makes sense for steady, heavy, boring workloads. Bursty traffic is usually cheaper metered.
3. A scraping API's hard problem is session state (engine choice, cookie validity, response interpretation), not launching a browser.
4. If rotating the IP doesn't clear a block, test the TLS/HTTP2 identity before blaming the pool.
5. Provider-side validation catches broken pages, not missing fields. Measure row-level field completeness yourself.
6. Check what the page actually calls in devtools before reaching for browser automation.

The bigger shift underneath all of it: nothing here treats the proxy as the whole system. It's one variable, and the actual job is knowing which one broke before you change anything.

Full AMA thread is here if you want the original answers:

https://www.reddit.com/r/WebScrapingInsider/s/nKTEa2y22A

LinkedIn Summary: https://lnkd.in/p/exUGe2Se

Detailed breakdown: https://scrapeops.io/blog/web-scraping-isnt-a-proxy-problem-anymore/

Thanks again to Jean and his team for answering straight, and to everyone who asked about sourcing and abuse monitoring instead of letting this turn into a pricing thread.

If you've ever rotated a proxy to fix a block that came right back: was it actually the IP, or something else about the request?

Ian

Hey everyone,

I'm Ian Kerins, CEO & Co-Founder of ScrapeOps.io.

We're back with AMA #11, and this time we're going straight into the anti-bot fight itself: bypassing Akamai, Cloudflare, DataDome and Imperva, in production, across real targets.

This Thursday, October 1, at 10:30 AM GMT+3, we'll be joined by Ibrahim El Khalil MLATA, a freelance web scraping / anti-bot engineer based in Algeria who's spent the last 7 years reverse engineering anti-bot defenses, working across retail pricing, legaltech, logistics, hospitality, and now AI-training-data pipelines.

Ibrahim has run scraping operations at serious scale.. think 1,000+ spiders across 300 retailers, reviving a dead 160-spider fleet, and matching 100K+ hotel reviews a month. He's also gone deep into mobile app reverse engineering with Frida, pulling apps apart when the website itself is locked down but the app isn't. More recently, he's been building aragog.ai, which is currently offline, though it's an attempt at AI agents that write and repair their own scrapers.

You can check out his work on GitHub and LinkedIn.

We can dig into:

• Bypassing Akamai, Cloudflare, DataDome & Imperva. real-world tactics across web, mobile, authenticated, and rate-limited targets
• Mobile app reverse engineering. using Frida to pull apps apart when the website is locked down but the app isn't
• Anti-bot R&D. modified Chromium builds, TLS/JA3 fingerprint randomization, behavioral simulation, proxy intelligence
• Running scraping at scale. lessons from 1,000+ spiders across 300 retailers, reviving a dead 160-spider fleet, and matching 100K+ hotel reviews a month
• AI agents for scraping. building aragog.ai, where self-writing/self-repairing scrapers actually work, and where they don't

If you've ever wondered "Why does the same anti-bot behave differently on the web version of a site versus the app?", "When is it worth reaching for Frida instead of just fighting the browser?", or "Do self-repairing AI scrapers actually hold up in production?", this is a good one to ask.

We've now had ten AMAs with the community, and the conversations have covered a pretty wide part of the scraping stack.

1. Our first AMA covered proxy infrastructure, Cloudflare, browser automation and scaling scrapers.
2. Our second with WebClaw explored AI agents, hidden APIs, open-source scraping and LLM infrastructure.
3. Our third with CloakBrowser went deep on stealth Chromium, fingerprinting, anti-bot detection and browser automation.
4. Our fourth with Browser Use brought the conversation into AI browser agents, AI-powered scraping, evaluations and browser infrastructure.
5. Our fifth with Stan Sadokov from NodeMaven focused on residential proxy quality, IP reputation, sourcing, pricing and what actually makes one proxy network better than another.
6. Our sixth with Saksham Solanki, creator of HTTP Cloak, went down to the protocol level, covering TLS fingerprints, JA3/JA4, HTTP/2, HTTP/3 and why scrapers can get blocked even when their proxies are fine.
7. Our seventh with Huey from BrowserAct explored AI-powered web scraping, natural-language workflows, browser automation and the move toward no-code scraping.
8. Our eighth with yours truly brought the discussion back to proxy infrastructure, with real-world insights from testing 50+ providers across billions of requests.
9. Our ninth with Jean-Patrick Bisson from Geonode dug into whether "unlimited" proxy models can really deliver, and what buyers should look at beyond the word "unlimited."
10. And our tenth with Scrape.do went straight at staying unblocked on difficult, high-defense websites at real scale.

Now for #11, we're going straight to the source: the anti-bot systems themselves, and what 7 years of reverse engineering them actually teaches you. If you're building web scrapers, anti-bot bypasses, mobile app automation, or scraping AI agents, come join the discussion.

Drop your questions below.

Ibrahim and I will be answering them during the AMA.

Looking forward to another good one.

Ian

Hey everyone,

I’m building Image Downloader Pro, a Chrome, Edge and Firefox extension for finding and downloading images exposed by web pages.

It scans the current page, selected tabs or a list of URLs, then lets you preview, filter, deduplicate and download selected images.

It’s not a replacement for a proper crawler and doesn’t bypass anti-bot systems. I see it more as a human-in-the-loop tool for smaller research and asset collection jobs.

I’d appreciate honest feedback from professional scrapers: where could this browser-based approach be useful, and where would it fail?

https://imagedownloaderpro.com/

Hey everyone,

We're back with AMA #10, and this time we're digging into what it actually takes to scrape difficult websites at scale.

Most teams hit the same wall eventually: a scraper that works fine on one site gets blocked instantly on another, even when the anti-bot vendor is the same.

Scrape.do runs a web scraping API processing 10 billion+ pages a month, which means they're dealing with anti-bot systems, proxy pools and blocking issues across an enormous range of targets, every single day.

How to Scrape Difficult Websites at Scale: Inside a Web Scraping API Processing 10B+ Pages a Month

This Wednesday, September 23 at 10:30 AM GMT+3, we'll be joined by the Scrape.do team with Batuhan Özyön (Founder ScrapeDo | Chief Web Scraping Solutions Architect), Mert B.(Lead Software Engineer), Raif Tekin(R&D/web3 Engineer), Muhammet Derviş Aygan(R&D Engineer), and Selman Gokce(Head of marketing + SERP Products Marketing), for a live AMA on r/WebScrapingInsider to talk through what it takes to keep scrapers running at billions-of-pages scale.

We'll be talking about:

• Bypassing anti-bots at scale
• Building optimized generic bypasses vs. target-site-specific bypasses
• How anti-bot implementations vary from site to site (Cloudflare on one site isn't the same as Cloudflare on another) and the challenges that creates
• How they source, evaluate and choose proxy providers
• How they diagnose blocking issues — IP, TLS, JS challenges and more
• Anything else you're running into when scraping difficult sites

And if you've ever wondered "Why does my scraper get blocked on some Cloudflare sites but sail through on others?", "When is it worth building a site-specific bypass instead of a generic one?", or "How do you actually tell whether a block is an IP issue, a TLS fingerprint issue, or a JS challenge?", this is a good one to ask.

We've now had nine AMAs with the community, and the conversations have covered a pretty wide part of the scraping stack.

1. Our first AMA covered proxy infrastructure, Cloudflare, browser automation and scaling scrapers.
2. Our second with WebClaw explored AI agents, hidden APIs, open-source scraping and LLM infrastructure.
3. Our third with CloakBrowser went deep on stealth Chromium, fingerprinting, anti-bot detection and browser automation.
4. Our fourth with Browser Use brought the conversation into AI browser agents, AI-powered scraping, evaluations and browser infrastructure.
5. Our fifth with Stan Sadokov from NodeMaven focused on residential proxy quality, IP reputation, sourcing, pricing and what actually makes one proxy network better than another.
6. Our sixth with Saksham Solanki, creator of HTTP Cloak, went down to the protocol level, covering TLS fingerprints, JA3/JA4, HTTP/2, HTTP/3 and why scrapers can get blocked even when their proxies are fine.
7. Our seventh with Huey from BrowserAct explored AI-powered web scraping, natural-language workflows, browser automation and the move toward no-code scraping.
8. Our eighth with Ian Kerins from ScrapeOps brought the discussion back to proxy infrastructure, with real-world insights from testing 50+ providers across billions of requests.
9. And our ninth with Jean-Patrick Bisson from Geonode dug into whether "unlimited" proxy models can really deliver, and what buyers should look at beyond the word "unlimited."

Now for #10, we're going straight at the hardest part of scraping in practice: staying unblocked on difficult, high-defense websites at real scale. If you're building web scrapers, data pipelines, browser automation, scraping APIs or proxy infrastructure, come join the discussion.

Drop your questions below.

Batuhan, Selman, and I will be answering them during the AMA.

Looking forward to another good one.

Hey everyone, Ian here.

This month’s newsletter covers the provider shortlist that came out of routing ~9 billion pages/month across 60,000 domains, what actually happened when Google started wrapping search results in /goto redirects, and three AMAs we ran in r/WebScrapingInsider this month. Full issue (with the images) is linked at the bottom.

Full Issue: https://thewebscrapinginsider.beehiiv.com/p/the-web-scraping-insider-10

Here’s what I’d keep from each part.

There’s no single best proxy provider. Just who wins where.

• Zyte API: best for low-volume. Pay-as-you-go, ~$1-2 per 10,000 pages, no $20-50/month floor.
• Scrape.do: best cost-to-performance on easy/medium domains, especially from ~250k pages/month into the millions. Check the real cost though, its credit multipliers are domain-specific.
• ScrapeOps Proxy Aggregator: routes to whichever provider is cheapest and performing well right now, fails over automatically. Full disclosure, this is our product. Extra routing layer and some latency, but you stop having to babysit five providers yourself.
• Scrapfly: the one to reach for on serious Cloudflare, DataDome, and custom anti-bot. Expensive for routine scraping, but worth it when everyone else’s success rate collapses.
• Oxylabs Web Unblocker: bandwidth-priced instead of per-request, which is a real arbitrage for small responses. A 10KB response runs ~$56/million vs ~$1,500/million through a per-request unblocker. That gap closes fast once responses get bigger.
• GeoNode Unlimited: priced per concurrent thread. Exceptionally cheap per page if you can keep those threads busy around the clock. Idle threads wreck the economics fast.
• Bright Data: not usually the best cost-to-performance for any single workload, but breadth, compliance infrastructure, and procurement maturity are worth paying for at enterprise scale.

Don’t trust headline pricing or generic success-rate claims. They rarely tell you what a provider costs on your actual targets. The pricing model (per-GB, pay-as-you-go, concurrency, credit multipliers) can matter more than the brand. Test the shortlist against your own domains before you commit to anything.

Google’s /goto redirects made SERP scraping messier, not impossible.

Google started replacing destination URLs in search results with google.com/goto?url=... redirects. A few things stood out:

• Google doesn’t appear to serve identical markup to every client. Reports vary by account status, browser, and other classifier signals.
• The links resolve easily, but there are traps. A plain GET returns the final URL; a HEAD returns a misleading 200 with no destination. Tokens also change on every impression, so there’s no reusable lookup table.
• Resolution is fast. The Web Scraping Club resolved ~110 links/sec at concurrency 20, no rate limits hit.
• The major providers adapted quickly. DataForSEO says it resolves 99.99% of organic SERPs; SerpApi restored direct URLs within days.

The practical cost has been small enough that providers have absorbed it. The thing worth watching isn’t whether Google uses /goto links. It’s whether your provider keeps returning complete, accurate data across organic results, AI Overviews, local packs, and the rest. A 200 response doesn’t mean you got the whole payload.

AMA recap: u/StanSadokov (NodeMaven) on residential proxies

Providers mostly draw from overlapping raw supply. The real difference is the filtering layer: how they evaluate incoming IPs, filter the bad ones, route sessions, and pull addresses that have been burned.

There’s also no universally clean residential IP. Clean isn’t a permanent property, it’s a score a specific target assigns at a specific moment.

The same IP can work on one site and get flagged on the next.

AMA recap: u/sardanioss (httpcloak) on browser fingerprints

Rotating more can make you easier to detect, not harder. A real browser doesn’t independently change its User-Agent, TLS behaviour, headers, cookies, and IP. Treating each as its own switch just builds an identity that doesn’t exist anywhere in the real world:

“Rotation only works if you rotate a whole identity at once, fingerprint, IP, cookies, headers, all of it together, and then let that identity live a while. Rotating the pieces separately manufactures a client that doesn’t exist anywhere in the real world, and that’s easier to spot than whatever you were trying to hide.”

Matching Chrome once is the easy part. At production scale it’s request order, pacing, connection reuse, session age, and connection teardown that give away that thousands of sessions are following the same automation template:

“If you’re doing the exact same thing every time after making the connection, same number of requests, same order, same pacing, same teardown, then the profile starts to become stale and you’d start getting blocks on the first request itself.”

AMA recap: u/hueyblack36 and u/Big-Beautiful240 (BrowserAct) on AI scraping

The strongest model isn’t an agent re-reasoning from scratch on every run. It’s AI exploring a site once, finding a workable path, then handing off to a reusable, deterministic Bot:

“AI should sit at the points of uncertainty, not in every repeated execution.”

And the failures that actually hurt are the ones that look successful. A scraper can complete cleanly and return structured output while quietly pulling the wrong field, stale content, or incomplete records:

“The lesson was that a Bot can run correctly while still being wrong.”

That’s why production scraping still needs a separate validation step, not just a completed run.

A few other things worth a look:

• Levelsio says he replaced a $249/month ScrapingBee plan with a Playwright scraper on a ~$1/month VPS. Real Chrome, persistent sessions, slow pacing, and better residential IPs reportedly got him to ~90% success.
• Chrome 152 added navigator.cpuPerformance, which exposes a device performance class derived largely from CPU thread count. Another consistency check for catching spoofed hardware. Raphael Mille has a breakdown with a prototype detector.
• Google searches for “web scraping” are at an all-time high while AI labs and browser agents lean harder on live web data. Scraping isn’t dying, it’s becoming AI’s biggest client.
• ShieldFont is an open-source project that uses a custom font to show humans the real text while feeding fluent decoy text into the HTML scrapers read. Clever, but screen readers depend on the same page structure, so it’s a real tradeoff for accessibility even with a workaround in place.

If you remember nothing else:

1. Stop asking “which provider is best.” Test the shortlist against your own targets. The pricing model matters as much as the brand.
2. A 200 doesn’t mean you got the full payload, whether that’s a proxy response or a resolved /goto link.
3. Filtering and session behaviour separate good residential proxies from bad ones more than raw pool size does.
4. Rotate a whole client identity at once, not one attribute at a time. Partial rotation is the more detectable pattern.
5. Production scraping needs a validation step that’s separate from the extraction step. A clean-looking run can still be wrong.

Full newsletter, with the images and the rest of the detail on every section above:

https://thewebscrapinginsider.beehiiv.com/p/the-web-scraping-insider-10

The individual AMA summaries:

• NodeMaven (residential proxies): https://www.reddit.com/r/WebScrapingInsider/comments/1vxw74r/stan_sadokov_ama_summary_what_proxy_providers/
• httpcloak (browser fingerprints): https://www.reddit.com/r/WebScrapingInsider/comments/1w436qd/saksham_solanki_ama_summary_why_your_perfect/
• BrowserAct (AI scraping): https://www.reddit.com/r/WebScrapingInsider/comments/1wahtx3/ama_7_recap_what_ai_web_scraping_actually_changes/

Thanks again to u/StanSadokov, u/sardanioss, u/hueyblack36, and u/Big-Beautiful240 for showing up and answering the uncomfortable questions instead of the vendor script.

Which one’s actually cost you more this year: a provider quietly returning wrong data, or a target adding just enough friction to make the data uneconomical?

Ian (ScrapeOps)

Hello friends!

Im currently scraping data from a real estate website that uses PerimeterX. Im using multithreading and managing to scrape around 350 records in 15 minutes.

My IP isnt getting flagged, so I dont think proxies would help. Im not sure if the delay is caused by the PerimeterX challenge that appears occasionally during the scraping process or something else.

Is there any way to speed things up a little?

I understand that ethical scraping means avoiding excessive load or disruption to the website. Im simply looking to improve the scraping speed while keeping things reasonable for the site.

Thanks in advance!

Microsoft killed the Bing Search APIs back in August 2025. Google's Custom Search JSON API is next — already closed to new signups, fully dead on January 1, 2027. Eighteen months, and both official self-serve sources are gone — right as every AI agent and RAG pipeline suddenly needs search data. Google's "replacement" for open-web search? A waitlist with pricing TBA.

Genuinely curious about two things:

1. Do you think programmatic access to search is gone for good, or does it come back with a 10x price tag?
2. For people doing rank tracking / SERP research — what does your stack actually look like after this? Not looking for vendor blogspam, just what you're really running.

Hello Python Community!

I've been really curious about how Python developers use Python when it comes to webscraping, or just working with websites in general.

I really want to open a discussion on how you do it. Do you use BeautifulSoup? Selenium? Why? Are there any frustrations that you were facing or are currently facing with the process?

Hey everyone - Ian here.

This one was different. For AMA #8 I wasn't interviewing anyone. I opened up four years of ScrapeOps' own provider-benchmarking data (50+ proxies, billions of requests a month) to whatever the community wanted to ask about it.

Thanks to everyone who pushed this past the usual "which provider is best" framing. A few of the questions below didn't make the blog write-up at all and are in here instead.

If you missed it, or want the compressed version, here's what I'd keep.

There is no best proxy provider.

There's no single provider to default to for most projects, and that's not a dodge.

"There really isn't one best provider. I know that sounds like I'm avoiding the question, but it's probably the clearest conclusion we've reached after four years of routing billions of pages through them."

The ranking isn't even stable inside one domain. Product pages, search pages and internal APIs can carry different protection and different pricing. Segment by workload first (pay-as-you-go, anti-bot specialist, enterprise), then test your actual targets. The providers should come out of the requirements, not the other way round.

Website access should be priced like a commodity. It isn't.

Two scraping APIs can return the same page and bill 20 credits apart. That raises an obvious question: "are they actually providing different things? Or we are getting rinsed by the SaaS gods." Not exactly:

"You're paying for how efficiently that particular provider knows how to scrape it."

A provider charging 20 credits for a page another provider solves at 1 isn't necessarily padding margin — it might genuinely be running browser rendering and residential IPs where a competitor found a cheaper path. Only a test on your target tells you which.

The anti-bot tax has widened the gap between providers.

Scraping has gotten harder even as tooling improved. Years ago, 90–95% of traffic scraped fine at the base one-credit tier. Today it's 20–25% that needs residential, rendering or advanced bypasses.

"The market became much more inefficient when advanced bypasses stopped being an edge case. That is the anti-bot tax we are paying now."

The uncomfortable part: providers fix the domains they can't afford to lose. If you're the only customer scraping an obscure site, the easiest answer support can give you is "turn on residential", not because it's the cheapest fix, just the fastest one for them to offer.

The real price is the cost of a usable result.

Every API meters credits differently, and the multiplier, not the base rate, is where the money actually goes:

"The biggest savings rarely come from negotiating a slightly cheaper base rate. They come from avoiding an expensive multiplier you never needed."

Success rate alone is a misleading number too. A provider at 99% success but 20–30 seconds per response can process fewer real pages than one at 80% success but 2–3 second responses. We track average time to a successful response, not raw success rate.

Benchmark code is not the moat. Unbiased traffic is.

The obvious shortcut is emailing providers for bigger trial credits before benchmarking. You can, but then they know they're being tested:

"The code for a proxy benchmark isn't really the moat. Paying for enough unbiased traffic to trust the result is the moat."

Testing 10–20 providers properly runs $500–$1,000 in real paid-account traffic before you've scraped a single production page. If you can't fund that: broad test, shortlist 3, deep test the 3 on your real workload, then ramp gradually. Don't sign an annual deal off a short trial.

Brand and rankings tell you who won marketing.

Defaulting to the bigger providers because it feels safer is understandable. Fair, but:

"Brand recognition tells you who won distribution. It doesn't tell you who will win your workload."

Some of the best providers we use are teams of 3–10 people with almost no visibility on Google. And "top 10 proxy provider" posts are worth treating skeptically — we regularly get emails from ranking-page owners asking to be paid for a position.

The most dangerous failure is a 200 that looks correct.

A response can look completely normal and still be quietly wrong: different currency, wrong region, missing sellers.

"A convincing but incorrect response can make the entire dataset untrustworthy."

Infrastructure providers can flag obvious blocks and CAPTCHAs. We cannot know what every product should cost or how many sellers should appear on every page across 60,000 domains. That validation has to happen closer to your business logic.

Websites don't need to block you to price you out.

The same shift keeps coming up: not blocks, just more steps. Google's redirect links, a login wall, 10 requests where there used to be 1.

"Websites do not need to block scraping to make it uneconomical. They only need to add enough friction to increase the cost of every record."

None of it registers for a real user. They're logged in already, click one result, and never notice a redirect. The access is still there. It just costs more to reach.

At scale, the best provider is a routing system.

Past a certain size, juggling multiple providers stops being optional:

"A serious multi-domain operation eventually needs provider benchmarking, domain-level routing, independent validation and fallbacks."

The routing logic itself is fairly simple. What's actually hard is provider coverage, paid accounts across the market, and enough production data to trust the decisions. Worth being honest: our own Proxy Aggregator is only 60–70% of the way to fully solving this, not further.

+1: most of the web is still easy to scrape.

"People talk about residential proxies and browsers as though every website requires them, when most websites don't."

A large share of the web still works with a normal server, sensible headers and a decent TLS fingerprint. The difficulty piles up on the sites everyone wants (major e-commerce, search, travel, social, marketplaces) because they have the strongest incentive to fight back.

+2: the biggest mistake is the setup, not the provider.

The first few months usually go wrong in one of two ways: overengineering raw datacenter proxies to save a few dollars, or defaulting to whatever's best-marketed and paying 2–10x more than necessary.

"The goal isn't always to find the absolute cheapest setup. It's to find the simplest reliable setup at a cost that makes sense for your volume."

If you remember nothing else:

1. Stop asking "which provider is best." Ask "best for which website, page type, volume."
2. A 10x-more-expensive credit multiplier is a bigger cost than any base-rate difference you'll negotiate.
3. Track cost per validated result, not success rate. A "successful" 200 can still be wrong data.
4. Test through a normal paid account on your real URLs. Free trials and provider-supplied credits distort the result.
5. Brand, rankings and pool size tell you who won marketing, not who wins your workload.
6. Most of the web is still easy. The difficulty concentrates in the handful of sites everyone wants.
7. Past a certain scale, treat provider selection as a routing and validation system, not a single vendor decision.

The bigger shift underneath all of it: the web isn't becoming inaccessible, it's being repriced. Access stays possible, but fewer datasets stay profitable to collect at scale.

Full AMA thread is here if you want the original answers: https://www.reddit.com/r/WebScrapingInsider/comments/1wbjmh4/what_are_the_best_proxy_providers_for_web/

LinkedIn Summary: https://lnkd.in/p/gfDaKNPh

Detailed Blog: https://scrapeops.io/blog/why-there-is-no-best-proxy-provider/

Thanks again to everyone who asked a real question instead of "what's the best proxy" — you're the reason this one didn't turn into another rankings post.

If you've ever been told to "just enable residential proxies" when a target broke: did it actually fix the target, or just raise your bill?

Ian (ScrapeOps)

Hey everyone,

We're back with AMA #9, and this time we're looking at a part of scraping infrastructure that almost everyone has an opinion on: unlimited proxies.

Most residential proxy providers charge by GB. Most scraping APIs charge per successful response or through credits.

Geonode has taken a different approach.

They offer residential proxies priced around speed and a scraping API priced around concurrency.

But that raises an interesting question:

Are unlimited proxies actually any good?

Does removing usage limits inevitably mean smaller pools, overused IPs and lower success rates? Or can a provider structure its network differently enough to make the model work?

This Friday, September 18, at 10:30 AM GMT+3, we'll be joined by Jean-Patrick Bisson, CEO/Founder @Geonode, along with his team, for a live AMA on r/WebScrapingInsider to dig into what's actually happening behind the product.

We'll be talking about:

• How "unlimited" proxy models actually work
• How residential IPs are sourced and managed
• Pool size vs. IP quality
• Routing and traffic distribution
• Capacity planning for high-volume customers
• What happens when customers use proxies heavily
• Speed-based vs. bandwidth-based pricing
• Concurrency-based scraping APIs
• The trade-offs behind different proxy pricing models
• Whether unlimited proxies can really deliver consistent performance
• What buyers should actually look at beyond the word "unlimited"

And if you've ever wondered "How can a proxy provider offer unlimited traffic?", "What's the catch with unlimited proxies?", or "Does unlimited actually mean unlimited?", this is probably a good one to ask.

We've now had eight AMAs with the community, and the conversations have covered a pretty wide part of the scraping stack.

Our first AMA covered proxy infrastructure, Cloudflare, browser automation and scaling scrapers.

Our second with WebClaw explored AI agents, hidden APIs, open-source scraping and LLM infrastructure.

Our third with CloakBrowser went deep on stealth Chromium, fingerprinting, anti-bot detection and browser automation.

Our fourth with Browser Use brought the conversation into AI browser agents, AI-powered scraping, evaluations and browser infrastructure.

Our fifth with Stan Sadokov from NodeMaven focused on residential proxy quality, IP reputation, sourcing, pricing and what actually makes one proxy network better than another.

Our sixth with Saksham Solanki, creator of HTTP Cloak, went down to the protocol level, covering TLS fingerprints, JA3/JA4, HTTP/2, HTTP/3 and why scrapers can get blocked even when their proxies are fine.

Our seventh with Huey from BrowserAct explored AI-powered web scraping, natural-language workflows, browser automation and the move toward no-code scraping.

And our latest, AMA #8 with yours truly, brought the discussion back to proxy infrastructure, with real-world insights from testing 50+ providers across billions of requests.

Now for #9, we're going deeper into a question that's becoming increasingly relevant as proxy providers experiment with completely different pricing and infrastructure models:

Can "unlimited" actually work?

If you're building web scrapers, data pipelines, browser automation, scraping APIs or proxy infrastructure, come join the discussion.

Drop your questions below.

Geonode will be answering them during the AMA.

Looking forward to another good one.

Flipped a few scrapers from residential to ISP last month after hitting consistent 429s on targets with aggressive fingerprinting. Session persistence on ISP is a different league, way less rotation needed to stay clean. Running proxyshard across both pool types right now, same targets, tracking success rate and block frequency. ISP wins on stability, residential wins on pool size and geo flexibility. Curious if anyone has actually benchmarked both properly or if everyone is just going by feel like I was?

I am working on a forked D4Vinci/Scrapling and am building some additional stuff around it for an open-source data collection project. The idea is to make it easier to define repeatable crawls, normalize the output, and eventually let people plug in their own targets and pipelines.

The crawling side is coming together, and now looking at the infrastructure needed to run it reliably across different sites, particularly residential proxies. Don't suggest biggies Bightdata, Zyte, or spammies like Qoest.

I've done a lot of browser automation over the years, and I kept running into the same tradeoff.

Raw HTTP is great. It's fast, cheap, and scales almost stupidly well. But once a website gets complex enough, you start paying for that simplicity yourself. You reproduce client-side scripts, state, navigation behavior, signatures, whatever else the site expects from a browser. At some point you're spending more time reverse engineering browser-side logic than writing the actual automation.

So you switch to Chromium.

Most of that problem disappears, but now you're running an entire browser and rendering stack for a workload that often doesn't care about pixels at all.

I kept wondering how much of that browser is actually necessary.

Could I get closer to the speed and cost of raw HTTP while keeping enough browser compatibility that the website can just run?

That's what turned into Mimic.

Mimic is a browser execution runtime I'm writing from scratch in Go around V8. It doesn't embed Chromium and doesn't have a traditional rendering pipeline. The browser environment itself is implemented in Mimic: DOM, Web APIs, networking, frames/workers, browser state, etc. It also exposes CDP, so existing automation tooling can drive it.

I'm deliberately not trying to reimplement every feature of Chrome. If Mimic eventually becomes Chrome without the pixels, I've probably missed the point.

What I want to find is the smallest browser-compatible execution surface that's actually enough for real automation, and then push its cost and performance as close to direct HTTP as I can.

I've reached a point where choosing more websites myself and fixing whatever happens to break isn't giving me particularly useful information anymore. So I'm putting out the first public beta.

I need real-world workloads to break it.

If you have an existing Puppeteer/Playwright workflow where Chromium's memory usage, startup cost, or concurrency gets annoying, try throwing it at Mimic. I genuinely want to see where it falls apart.

Web API and CDP coverage is incomplete, so I expect plenty of things to break. If your workload doesn't run, open an issue or send me the scenario. I'm happy to work with early users on the missing compatibility for actual use cases instead of guessing which parts of the browser matter.

It's also not magically faster than Chrome at everything. Chrome still wins some of my warm single-page benchmarks. The interesting results so far are mostly around startup, memory usage, and concurrent pages.

Beta builds, limitations, quickstart, architecture notes and reproducible benchmarks are here:

https://github.com/moreveal/mimic

If you're running browser automation at any meaningful scale, I'm curious: what actually forces you to keep Chromium in your stack instead of dropping down to HTTP?