Do not treat a provider switch as a hostname change. A safe migration from ScrapingBee is a behavior-parity project: inventory the options your client actually sends, map each one to the replacement API, adapt authentication and response decoding, then compare representative pages, failures, latency, throughput and cost before moving production traffic.
Zyte API is a useful worked example because Zyte publishes a ScrapingBee migration guide. It is not a universal drop-in replacement; unsupported options and a different response contract require application changes.
What changes when you leave ScrapingBee?
ScrapingBee’s HTML API accepts a target URL and API key and enables JavaScript rendering by default. Rendering and proxy choices affect credit consumption. Its current documentation recommends bearer-token authentication; query-string api_key authentication remains available for backward compatibility but is documented as deprecated. Record the behavior of your existing integration before changing it.
In Zyte’s documented migration example, the transport and payload both change:
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstall#1 Best Overall
| Concern | ScrapingBee pattern | Zyte migration pattern |
|---|---|---|
| HTTP method | GET | POST |
| Request encoding | URL-encoded query parameters | JSON request body |
| Authentication example | API key (bearer recommended in current docs) | HTTP Basic authentication |
| Response | Target content returned directly | JSON response object |
| Target body | Direct HTML or requested output | Base64-encoded body inside the JSON object |
That means your code must change request construction, authentication, response parsing, decoding, error handling and often logging. A replacement can produce valid HTTP responses while still changing page completeness or extracted fields.
Sources: ScrapingBee API documentation and Zyte’s ScrapingBee migration guide.
1. Inventory the ScrapingBee behavior you actually use
Read production client code, configuration and downstream parsers. Do not infer usage from a tutorial request containing only url and an API key.
Request controls to record
- JavaScript rendering and navigation or rendering waits.
wait,wait_for, selector waits and any network-idle logic.js_scenarioactions such as click, fill, scroll and wait.- Country or geolocation settings, premium or stealth proxy modes and custom proxies.
- Custom headers, cookies, user-agent values and authorization headers.
- Screenshot settings, selected elements and full-page behavior.
- Extraction rules, structured selectors, AI extraction and requested output formats.
- Timeouts, retries, concurrency, status-code handling and cache behavior.
Output and operational assumptions
- Whether parsers expect raw HTML, text, Markdown, JSON or an image.
- Whether the code reads response headers, cookies or the target status code.
- How base64, compression and character encoding are handled.
- Which errors are retryable and which are permanent.
- How usage, credits, latency and successful extraction are measured.
Keep this inventory in version control. It becomes your migration checklist and prevents an apparently unused option from disappearing during the rewrite.
Free tools Windows power users keep installed
One-click scans. No signup required.
2. Build a request-and-response adapter
Separate provider-specific transport code from scraping and extraction logic. Your parser should receive a normalized internal object, regardless of which API supplied it.
ScrapingBee-style request (current bearer-token form)
curl -G "https://app.scrapingbee.com/api/v1/"
-H "Authorization: Bearer $SCRAPINGBEE_API_KEY"
--data-urlencode "url=https://example.com/product"
--data-urlencode "render_js=true"
--data-urlencode "wait_for=.price"Use the exact endpoint and options from your account’s current documentation. If your legacy client places api_key in the query string, migrate authentication deliberately rather than copying that pattern to a new provider.
Zyte-style POST and decoding example
curl -u "$ZYTE_API_KEY:"
-H "Content-Type: application/json"
-d '{
"url": "https://example.com/product",
"browserHtml": true,
"actions": [
{"action": "waitForSelector", "selector": ".price"}
]
}'
https://api.zyte.com/v1/extractThe migration guide’s contract returns JSON and encodes the target body as base64. Decode it only after checking the HTTP status and the provider’s structured error fields.
import base64
import requests
r = requests.post(
"https://api.zyte.com/v1/extract",
auth=("YOUR_ZYTE_API_KEY", ""),
json={"url": "https://example.com/product", "browserHtml": True},
timeout=90,
)
r.raise_for_status()
data = r.json()
html = base64.b64decode(data["browserHtml"]).decode("utf-8", errors="replace")
Use a normalized result such as {status, headers, body, provider, timing, usage, error}. Have the adapter preserve enough metadata for observability without coupling business code to either vendor’s field names.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →3. Map features one by one
Zyte documents common equivalents, but the mapping is not one-to-one. Treat every row as a design decision and verify the resulting page, not merely the request’s acceptance.
| ScrapingBee need | Documented Zyte direction | Migration caution |
|---|---|---|
| JavaScript rendering | Browser HTML | Confirm the returned field and browser timing. |
wait or wait_for |
Browser actions such as waiting for a selector | Selectors and action syntax differ. |
| Click, fill, scroll and wait actions | Zyte actions | Rewrite sequences and test stateful pages. |
| Premium proxy | Residential IP type | Pricing and availability are provider-specific. |
country_code |
Geolocation controls | Check whether location applies to IP, browser or both. |
| Ad or resource blocking | Unsupported in the migration table | Recreate blocking in your own pipeline or change requirements. |
| Custom proxies | Unsupported in the migration table | Do not silently assume your existing proxy pool carries over. |
| Server-side extraction rules | Unsupported in the migration table | Move extraction downstream or redesign it. |
| Selected screenshot targeting | Not fully equivalent | Validate the exact screenshot requirement. |
| Some request controls and headers | Provider-specific or unsupported | Compare the effective request sent to the target. |
Unsupported does not automatically mean impossible. It means you must choose between implementing the behavior yourself, changing the workflow, retaining a separate capability, or selecting another provider. Document that decision for each production option.
4. Test parity before production cutover
Create a representative fixture set
Sample the real workload rather than testing only a static homepage. Include ordinary server-rendered pages, JavaScript-heavy pages, pages requiring waits, interaction flows, geolocation-sensitive content, blocked or slow targets, and every output format your application consumes.
Compare content, not just status codes
- Required fields and item counts in the extracted result.
- Presence of lazy-loaded images and client-rendered text.
- Character encoding, canonical URLs and relevant response metadata.
- Target status, provider status and structured error details.
- Latency distribution, timeout frequency and retry outcomes.
- Duplicate, stale or partially rendered pages.
Save normalized fixtures and diff them automatically. A 200 response that omits a price, review list or consent-dismissed content is a failed migration for that use case.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Exercise complex cases separately
Zyte recommends trying and comparing equivalent requests and testing complex use cases before migration. Run action sequences, proxy escalation, location changes and extraction paths independently so a failure has an identifiable cause. Keep the old provider available during the comparison window.
5. Recalculate cost and throughput using your traffic
ScrapingBee’s documented credit model varies by configuration. Its current HTML API documentation states that JavaScript rendering is enabled by default and costs 5 credits for a standard request. Premium proxy use is documented as 25 credits with JavaScript rendering and 10 credits without it. Stealth proxy requests are documented at 75 credits per successful API call, with limitations, and AI extraction options add 5 credits. These are vendor terms that can change; verify the live documentation and your account usage.
Auto-Mode can try configurations from cheaper to more expensive and charge for the configuration that succeeds, with an optional cap. Model that escalation when estimating spend; counting URLs alone is misleading.
Zyte’s migration documentation describes pay-as-you-go usage, spending limits or commitments and RPM-based limits. ScrapingBee describes concurrency-oriented limits. Compare the two using your page mix, successful volume, browser-rendering rate, proxy escalation, extraction options and required peak throughput. Neither service is universally cheaper or faster from headline pricing alone.
| Metric | How to calculate it |
|---|---|
| Effective cost per successful extraction | Total provider spend divided by records that pass validation. |
| Browser escalation rate | Requests requiring rendering or premium access divided by all requests. |
| Throughput headroom | Observed sustained requests per minute versus your peak requirement and provider limit. |
| Retry overhead | Additional requests caused by timeouts, transient errors and validation failures. |
6. Roll out with observability and rollback
- Deploy the adapter behind a provider switch or feature flag.
- Send a small, representative share to the candidate while retaining ScrapingBee as the fallback.
- Track request volume, successful extraction rate, target and provider statuses, latency percentiles, retries, normalized field failures and spend.
- Alert on parity regressions, not only HTTP errors.
- Increase traffic only after the candidate remains within your acceptance thresholds.
- Keep credentials, configuration and rollback routing ready until real traffic confirms the change.
A staged rollout is an engineering precaution derived from the changed response shape, unsupported features and different rate-limit models; it is not a vendor guarantee.
Or skip the browser setup
If your requirement is dependable website screenshots rather than a general HTML extraction rewrite, ScreenshotNeo provides a separate API and MCP server. It accepts consent banners before capture and removes more than 60 known consent platforms, newsletter popups and chat widgets; each cleanup step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing result.
One GET request returns PNG, JPEG, WebP or PDF:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for the full option set. The same service supports full-page captures with lazy images loaded, CSS-selector element captures, dark mode, 12 device presets and custom viewports, retina scale, PDF paper size and page ranges, HTML/CSS rendering, custom JavaScript, clicks, selector waits, delays, network-idle waits, request and resource blocking, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, caller-selected cache TTLs, signed image links, asynchronous jobs with signed webhooks, bulk capture of 100 URLs per call, usage reporting and an OpenAPI specification. Common parameter names used by other screenshot APIs also work, which can reduce rewrite effort.
Python
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)Node.js
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`ScreenshotNeo HTTP ${res.status}`);
const data = Buffer.from(await res.arrayBuffer());ScreenshotNeo has an MCP server with take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients. Every feature is available on every plan: 1,000 screenshots per month free without a card; Starter is $5 for 3,000, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000 and Business $249 for 1,000,000. Yearly billing provides two months free. Create a free ScreenshotNeo account to start with the 1,000 monthly screenshots.
Recommended Free Tools
Troubleshooting migration failures
401 or 403 after the switch
Check the authentication scheme, header spelling, credential scope and whether the key is being sent to the intended host. Do not assume a ScrapingBee bearer token format is valid for Zyte Basic authentication.
200 response but parser receives no HTML
Inspect the response content type and envelope. Zyte’s documented response is JSON with a base64-encoded target body; parse the JSON and decode the correct field before invoking the HTML parser.
JavaScript page is incomplete
Map rendering and waits explicitly. Replace fixed delays with a selector or action wait where possible, then verify that the selector represents the data your parser needs.
Interactions no longer work
Rewrite click, fill, scroll and wait sequences in the destination provider’s action syntax. Confirm ordering, selectors and whether each action runs in the same browser context.
Requests become unexpectedly expensive
Audit rendering, premium or stealth proxy escalation, AI extraction and retries. Compare successful-request cost, not URL count, and account for Auto-Mode’s possible escalation.
Best Value
Throughput drops despite valid responses
Measure concurrency and RPM separately. A provider using RPM limits can behave differently from one enforcing concurrency; reduce burst size, add backoff and verify the destination’s current limit for your account.
Fields differ only for some countries
Check geolocation mapping, proxy location and timezone independently. Run the same fixture with an explicitly recorded location and compare the effective request settings.
Migration checklist
- Inventory every request option and downstream output assumption.
- Choose a normalized internal response contract.
- Rewrite authentication, method, serialization and response decoding.
- Map supported, changed and unsupported features explicitly.
- Build representative fixtures, including complex browser cases.
- Compare content quality, failures, latency, throughput and effective cost.
- Instrument usage and extraction validation before cutover.
- Roll out gradually with a tested rollback path.
Frequently Asked Questions
Is Zyte API a drop-in replacement for ScrapingBee?
No. Zyte’s documented migration changes the request from GET with query parameters to POST with JSON, uses a different authentication example, returns a JSON envelope and base64-encodes the target body. Feature support also differs.
Which ScrapingBee option should I migrate first?
Start with options your production traffic actually uses, especially rendering, waits, actions, proxy or geolocation settings, extraction and response handling. A parameter-by-parameter inventory is safer than migrating in documentation order.
How long should a parallel comparison run?
There is no universal duration. Run it long enough to include representative page types, traffic peaks, retries and geolocation or interaction cases, then use your acceptance thresholds for extraction success, latency and cost.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
