Changelog

aggregate per-vendor per-tier success-rate telemetry

migration-ledger drift detection - reconciliation + content_hash verification

restore 2 of ~11 blog posts as new forward content

fail loudly on missing support-inbound credentials at startup

extend staleness-probe to antibot_hint cold-start engine-profile fallback

surface active and scheduled maintenance on /status

DR script guards, TOCTOU close, and legacy-sidecar restore coverage

announcement CTA model residue — userinfo threat model + PublicCTA length parity

route cold-start antibot_hint fallback through shared vendor_engine

resolve announcement CTA href residue from

unvalidated input and missing startup validation — 3 fail-loud-before-use gaps

per-domain concurrency gate is a third, unaccounted-for min_tier consumer

stop 10 error-trigger.sh checks from silently skipping on cloud provider

Default POSTGRES_DB=alterlab / POSTGRES_CONTAINER=alterlab-postgres match production

retry unclassified origin 5xx via proxy, stop false WAF attribution

container-ro fails closed when jq is missing, not silently open

polish — declarative patch validation, cancel endpoint, audit-field docs

We have published a clear, formalized data retention and recovery policy for past scraping jobs. This helps development teams accurately plan their local data synchronization intervals and log storage strategies.

Upgraded background task cleanup logic to prevent premature task cancellation during platform updates. Active jobs and cleanup operations now gracefully persist or complete without interruption.

Upgraded safeguards in our credit refund retry pipeline automatically isolate processing failures. This ensures credit transactions are never lost or unaccounted for under any network conditions.

Plus 47 internal improvements for better reliability and performance.

Fixed a refund loop that triggered duplicate refunds when accounts had insufficient balances. This ensures completely accurate credit accounting for all structured scraping requests.

Fixed a balance discrepancy for accounts with negative credit balances during refunds or credit grants. Real-time balance caches now perfectly align with your ledger history to ensure accuracy.

Added per-IP rate limiting to the API readiness endpoint to protect platform availability from accidental high-frequency polling. This ensures health checks remain responsive under heavy load.

rehearse pending migrations against a restored production-shaped database before deploy

add scheduled backup restore drill

flag .env.example changes with no ENV_VARS.md statement in PR body

surface backup gate age/status in Slack and Discord deploy notifications

shadow-database migration dry run in CI

define jobs retention/recovery policy

batch of P2/P3 review findings — offsite-backup.sh & backup-database.sh

close residual TOCTOU between fresh ledger read and cache upsert in reconcile_all_inconsistent_balances

scope jobs pg_dump exclusion to the pre-migration path only

add retention policy for credit_balance_mutations audit table

serialize restore_from_backup and reap_broken_databases with a shared lock

prevent duplicate structure enqueue after ambiguous cache write

set executable bit on five command-target scripts

We moved structured data conversion off the API response path and directly cached the outputs. This eliminates redundant processing and cuts response latency by up to 8 seconds for cached structured results.

We optimized proxy allocation rules to eliminate a 1-second latency floor for basic scraping tasks. Requests that do not require custom proxies are now completed in just 40 to 109 milliseconds.

Our connection multiplexing for synchronous scrapes has been fully redesigned. This significantly reduces connection bottlenecks and improves query response times during heavy parallel scraping workloads.

Lightweight extraction tasks under 50 KiB are now processed directly within the scraping stage, eliminating unnecessary staging hops. This reduces delivery overhead and ensures faster turnaround for small-scale datasets.

API credential validation is now optimized to run directly from high-speed cache memory without hitting primary databases on subsequent requests. This lowers authentication latency while maintaining real-time revocation capabilities.

Scraped assets and headers are now automatically built using the correct country context matching your assigned proxy. This ensures highly localized and accurate web scraping results across all target regions.

Active spending reservations are now instantly released when an API request fails validation checks. This guarantees that failed or rejected requests never artificially count against your spending or concurrency limits.

Webhook URL validation is now completed before any charges or debits are applied to your account. This ensures invalid destination URLs are rejected immediately with no temporary billing impact.

Active scraping jobs are now automatically and safely requeued if a processing node undergoes scheduled maintenance or shutdown. Your jobs are guaranteed to finish executing seamlessly without being dropped.

Support ticket submissions and replies now validate attachments before sending, preventing silent file failures. You will receive real-time warnings, accessible error feedback, and retry controls for any failed uploads.

Optimized search engine fallback latency by enforcing a strict 25-second deadline for parallel dispatch, fallback, and parsing. This ensures your search API calls reliably return responses within the 30-second client window.

This release also includes several general reliability enhancements. These include automatic background retries for failed search refunds, accessibility labeling improvements for support screens, and corrected billing scopes for multi-user accounts.

Enforced strict, normalized ownership scopes on support ticket attachments. Unauthorized attempts to query or access ticket media now return a generic 404 error, fully protecting your uploaded support files.

Feat: replay worker for the billing:refund_retry dead-letter

Fix: format API and internal service CI failures

Fix: spend-guard decrement atomicity in structure shutdown finalize

Fix: retain discovery cooldown after expired cache write fallback

Fix: re-read cache write-degraded state after discovery lock wait (review finding - )

Fix: surface failed search refunds

Fix: use one principal for debit and refund

Fix: enforce attachment size before buffering

Fix: preserve debit metadata for restart recovery refunds

Fix: preserve attachment storage across GC commit failure

Fix: bound attachment backfill lock during deploy

Fix: enter bounded discovery backoff after cache cache write failure

Structured scraping requests now complete up to one second faster. By replacing polling intervals with instant queue handoffs, your extracted data is delivered immediately after the page is scraped.

Scrape requests that only require raw HTML responses now completely bypass the structuring queue. This optimization removes unnecessary processing to deliver your raw content significantly faster.

We capped individual retry timeouts for advanced browser-based requests. This eliminates the long latency tail, ensuring slow requests either failover rapidly or resolve within a predictable time limit.

Our automatic data extraction engine now automatically self-heals when encountering offline AI model providers. This protects your parsing pipelines from external service disruptions.

Plus 15 internal improvements for better reliability and performance.

You will not be billed for scrapes that encounter block pages, challenges, or system errors. Our detection systems now identify these occurrences to ensure false successes are refunded immediately.

Structured scrape responses now return the actual HTTP status code from the targeted upstream website rather than defaulting to 200. This enables more precise error handling in your application.

Scrapes that return successful responses from non-200 pages, like soft-404s, are no longer falsely marked as failed in your usage analytics. This ensures your dashboard metrics are accurate.

Dedicated proxy sessions now benefit from automated clean-IP pre-screening. The system automatically rerolls blacklisted addresses before your request is sent.

You can now manage and cancel subscriptions directly within your customer billing portal. This ensures a smoother and more self-sufficient experience.

Browser sessions now dynamically match the timezone and locale of the proxy exit IP. This ensures a cohesive geo-profile that bypasses strict security checks.

We enabled IP and provider diversity checks across all scraping requests by default. This automatically routes traffic to avoid localized range blockages.

Our platform now detects when websites use multiple overlapping security systems. The API dynamically applies the best routing strategy for each layer.

Automated session tools now utilize fully modernized browser signatures. These profiles correctly align User-Agents with matching client hints.

Plus 19 internal improvements for better reliability and performance.

Resolved an issue where concurrent requests using identical fingerprints were fired instantly. A micro-stagger now prevents target sites from flagging traffic.

Fixed a bug where different internal checks could evaluate different IPs. The system now strictly threads the same resolved address across all security checks.

Resolved an issue where concurrent proxy requests could share or overwrite settings. Sticky sessions are now completely isolated across target domains.

Added idempotency protection when generating billing configurations. This prevents duplicate sessions from being created during concurrent client clicks.

Cookies for target domains with special characters are now correctly cached. This avoids unexpected re-verification loops on secure websites.

Request timeouts now record specific failure reasons in your usage tracking metadata. This simplifies troubleshooting for slow target websites.

This release also resolves several minor issues. We fixed server errors on support pages, preview flash glitches, and background resource cleanup.

You can now maintain a consistent residential IP and share cookies across sequential requests using a session handle. This simplifies multi-step tasks like logging in and then scraping data.

You can now update your company billing address and tax ID directly from the self-serve billing portal. This ensures that automatically generated invoices reflect the correct corporate details without needing manual support.

Stateful session IP pinning is now supported across all scraping tiers, including direct HTTP requests. Sequential calls to simple and complex pages alike will now share the exact same residential IP.

Credit pre-estimations for browser-tier tasks are now calculated accurately at submission. This prevents temporary over-billing and ensures your playground balance matches the final processed tier pricing.

The Node SDK now includes client-side validation for stateful session handles and lifetimes to match the Python SDK. This provides immediate feedback on invalid inputs before sending requests to the API.

Plus 22 internal improvements for better reliability and performance.

The billing dashboard layout has been optimized to reduce empty vertical space and group active details more compactly. Active payment methods, recharges, and receipt tables are now positioned for easier scannability.

Resolved a concurrency race condition in stateful sessions that could cause captured cookies to be dropped when scraping in parallel. Your shared cookie jar remains accurate during concurrent actions.

Captured browser cookies are now correctly recorded and available in your stateful sessions. This enables seamless, stateful transitions between standard HTTP scraping and browser-driven actions.

Requesting browser-only features without enabling JavaScript rendering now returns a clear validation error. This prevents silent execution failures on incompatible non-JS tiers.

Fixed a routing leak in fast-fetch discovery calls during stateful sessions to guarantee that all traffic stays pinned. All sub-requests now strictly maintain your designated residential exit IP.

Stateful sessions now return a clear indicator when a session has expired or dropped rather than failing silently. This allows you to easily detect lost states and re-initialize sessions.

Fixed a parsing crash when converting complex, deeply nested HTML structures into clean markdown or JSON. This prevents unexpected validation errors when scraping highly structured pages.

Fixed a dashboard issue where balance refresh errors could cause unhandled promise rejections. This stabilizes the developer playground interface during balance updates.

We resolved a session-saving bug where fully invalid or malicious cookie harvests could accidentally overwrite and erase your existing valid cookie jars. Your active, functional session credentials will now be safely preserved.

We corrected a response metadata issue where request logs mislabeled session status as active for standard sticky sessions. Your API response logs now accurately reflect the exact proxy configuration utilized.

Stateful session cookies are now securely scoped to their specific domains. Reusing a single session handle across different host domains will no longer leak or replay cookies between them.

Captured session cookies are now sanitized to strip control characters and limit payload sizes. This protects stateful operations and prevents unexpected errors during session replay.

Cross-origin cookies from third-party iframes are now strictly filtered and isolated from your session's cookie jar. This prevents unauthorized third-party cookies from being replayed to your primary target domains on subsequent requests.

If a target URL fails to parse during request scoping, the connection now fails closed by default rather than exposing unfiltered cookies. This ensures zero risk of cross-origin leakage during complex navigation paths.

Our request screening now rejects non-standard C1 control characters and Unicode line separators in session inputs. This defense-in-depth update blocks sophisticated injection techniques that exploit lenient parser behaviors.

Response cookies and active session updates are now subjected to rigorous sanitization before ingestion. This closes sanitization gaps and prevents malformed cookies from destabilizing your session jars.

To protect sensitive active data, session-specific proxy tokens are now completely redacted from all system logs. This guarantees your active credentials remain private during execution.

Automatically detects and extracts content from pages whose primary text is nested inside same-origin iframes. This ensures that media-heavy or app-like pages are captured completely.

You can now manage your legal billing identity directly from your organization dashboard. This information automatically synchronizes with our billing systems.

Enhanced Google search result and ad-capture reliability to prevent silent fallbacks and missing data. Your search scraping queries are now more consistent and complete.

Scrapes returning empty main text content are now automatically refunded. This ensures you only pay for successful extractions on pages with readable text.

Improved session and cookie continuity when retrieving supplementary product and seller offer details. This prevents authorization issues and improves data completeness.

The image selection algorithm now uses deterministic tiebreakers to ensure reproducible and consistent results. You will now get identical image rankings across repeated scrapes.

Malformed AWS Role ARNs for custom S3 delivery are now validated and caught early at write time. This prevents downstream delivery failures and silent errors on execution.

Credentials validation for cross-account S3 deliveries has been optimized to run completely non-blocking. This prevents queue stalls and maximizes overall throughput.

Plus 23 internal improvements for better reliability and performance.

Our checkout system now prompts for and collects your billing address and tax/VAT info during purchase. This ensures auto-generated invoices are fully compliant.

Self-serve users can now directly access the payment portal to manage their payment methods. The portal link is now fully accessible on the billing dashboard.

We have redesigned the billing page layout to support accounts with a high volume of transactions. The dashboard now features a clean and perfectly aligned layout.

The billing dashboard now loads instantly by leveraging cached document URLs rather than requesting live links on every render. This eliminates page hangs.

Prevents 300-second timeouts on extremely long or iframe-heavy pages when JavaScript rendering is enabled. This ensures complex sites finish loading within normal limits.

Resolved issues with advertiser transparency details to consistently return accurate names, verification statuses, and locations. This improves data reliability for marketing research.

Fixed dashboard and receipt history rendering so that paired account recharges are no longer hidden. This ensures your billing statements and balances match up perfectly.

If a request successfully retrieves a page but the subsequent data-extraction stage fails, your account is now automatically refunded. This prevents lost credits.

We resolved an issue where structured data extraction from deeply nested HTML pages would occasionally crash. The extraction engine now handles complex layouts reliably.

Requests that return regional or geographical restriction block pages are now correctly recognized as failures. These requests will no longer be counted as successful.

We fixed an issue where attempting to clear an optional billing field was ignored by the backend. You can now freely clear and update all organization billing fields.

We added a loading guard to prevent slow connections from displaying incorrect billing data when switching accounts. Billing fields now reset cleanly and synchronously.

Upstream error details from our payment processors are now thoroughly sanitized before being returned. This prevents internal processor details from being exposed.

We added strict hostname validation to the billing receipt download proxy to prevent open-redirect vulnerabilities. This ensures you are only redirected to authorized domains.

Reclaiming an account now completely deletes any associated billing profiles and payment details from the provider. This ensures unauthorized profiles do not survive recovery.

Feat: billing identity — legal name, address, VAT/tax ID on Organization

Fix: outbound billing-identity PUT vs delayed customer.updated webhook ordering gap

Fix: customer.updated webhook silently drops address/name/tax ID

Fix: Stripe Checkout never collects billing address or VAT/tax ID

Fix: deploy-production honors dispatched --ref instead of silently reverting to main

Fix: hotfix- bash syntax error from Go-template under appleboy/ssh-action

Fix: billing page hangs — stop fanning out to Stripe on every render

generalize deploy sync to cover all infra/ssh-guard/ files

Fix: Stripe Customer Portal link unreachable for self-serve customers

Fix: remove fabricated Spending by Type card from billing page

Fix: demote alterlab from SUPERUSER, add alterlab_admin for migrations

Fix: changelog generator duplicate version headers

Fix: CloudFront geo-block pages billed as T4 success

Fix: restore prod DB reads for monitor via read-only monitor_ro role

Fix: add deploy-time orphan-container detection

Fix: monitor user was root-equivalent — allowlist container access, add read-only observability

You can now resolve or reopen support tickets directly using your API keys, removing the need for user JWTs. This simplifies the process of automating ticket lifecycles within your own systems.

You can now programmatically update ticket priorities and tags using API key authentication. This lets you integrate automated ticket classification systems directly into your workflow.

We have introduced a new API endpoint to merge duplicate support tickets programmatically by reference. This allows your team to automate the cleanup of redundant incoming customer requests.

Deferred requests now resume with millisecond-level precision instead of waiting a flat 5-second ceiling. This significantly increases your overall scraping throughput.

Proxy routing now distributes concurrent requests across a wider pool of exit IPs. This prevents traffic concentration on single IPs and dramatically reduces rate-limiting blocks.

The platform now prevents unnecessary escalation to expensive browser-based scraping tiers during transient network or proxy degradations. This keeps your API usage highly cost-effective.

Scraping requests now incorporate natural inter-request delays and paced retries on failure. This human-like behavior reduces detection rates on websites with strict bot protection.

We have introduced new agent-friendly documentation routes. This allows developers' AI assistants to easily parse and query our API schemas for seamless integration.

IP blacklists are now strictly enforced in rotating proxy mode. The system automatically re-rolls to a clean connection if a known bad or burned exit IP is detected during a request.

When targeting JSON API endpoints, the parsed response body is now cleanly exposed in the content JSON field. This makes extracting structured data much more straightforward.

Plus 47 internal improvements for better reliability and performance.

Automatically extract prices for products under Amazon's Minimum Advertised Price restrictions. The API now retrieves hidden prices instead of returning empty fields.

Low-volume domains now transition to cheaper scraping tiers much faster once success is proven. This prevents requests from getting stuck on expensive browser-rendering tiers, saving you credits.

Requests requiring automatic browser escalation now retry on an optimized schedule instead of sharing standard delays. This significantly reduces overall latency and ensures jobs complete faster.

Eliminated unexpected latency spikes when starting requests after the scraper has been idle. Queue poll delays are now strictly bounded, resulting in faster and more consistent response times.

Active scraping sessions are now protected from premature background cleanup tasks. This eliminates unexpected session terminations and ensures long-running requests finish successfully.

Requests returning empty HTML shells with no visible content are now correctly identified and escalated. This ensures you always receive complete and valid page data.

We resolved a dashboard bug where auto-recharge transactions were displayed as non-clickable items. You can now easily view and download invoice receipts for all transactions.

Submitting whitespace-only notes will no longer generate empty, confusing ticket responses in the system. This keeps your support communication clean and readable.

We added validation to S3 delivery configurations during creation and credential rotation. This prevents configuration errors, such as missing external IDs, before they cause delivery failures.

Restored reliable escalation to browser rendering for pages that return extremely short, non-JSON initial responses. This ensures that minimal landing pages are properly rendered and resolved.

Resolved an initialization issue that could prevent the automatic configuration of LLM-based extraction models. Your AI-assisted parsing tasks will now configure and run reliably on startup.

We upgraded our job delivery system to automatically recover tasks affected by unexpected transient errors. This ensures your scraping requests are completed reliably without getting stuck.

Plus 10 internal improvements for better reliability and performance.

We resolved a high-concurrency race condition to ensure strict data isolation for custom proxy configurations. Your proxy integration details are now fully secure during concurrent scraping jobs.

Users can now seamlessly reclaim their email addresses during sign-in if their email was previously registered via unauthenticated signup. This process automatically revokes unauthorized credentials and secures your account data.

Our automatic recovery now uses recent success rates instead of lifetime averages. This allows the platform to instantly adapt and bypass detection on domains experiencing sudden degradation.

A new 15KB minimum content threshold applies across all scraping paths. This ensures empty pages or small anti-bot screens are marked as failures and never billed as successful scrapes.

We added context manager support and explicit close methods to the Python SDK. This properly cleans up client sessions and active event loops, preventing persistent background memory leaks.

An optimized single-pass parser now handles unclosed elements in HTML documents. This eliminates processing lag and speeds up markdown extraction for complex, structured pages.

The platform now detects IP-level connection rejections to instantly block wasteful escalation. This ensures faster failover, reduced latency, and overall smarter request routing.

AI-powered scraping tasks are now more resilient to third-party model deprecations. The system automatically redirects queries to active fallback pools, preventing unexpected 404 errors during extraction.

The Node SDK now supports subpath imports for helper modules. Developers can import utility modules like cookie encryption directly using standard paths without encountering module resolution errors.

We standardized our SDK references to use the official npm package name, alterlab. Documentation, templates, and public examples have been updated to ensure smooth integration without using outdated package names.

We updated our affiliate commission payouts to align with our standard rewards policy. Affiliates now receive a 20% commission on their referred user's first deposit, capped at a maximum of $10.

We optimized DNS caching and watchdog intervals across our web scraping worker fleet. This resolves transient resolution failures under heavy scraping volumes, making concurrent network requests much more stable.

Fixed an issue where billing webhooks failed during automatic recharges or deposits. This ensures billing transactions and credit top-ups process instantly without account disruption.

Fixed a bug where digest, billing, and credit emails reported a zero percent success rate. Email metrics are now fully accurate and reflect the true success outcomes of your jobs.

Fixed an issue in the Node SDK's fetch wrapper where multiple Set-Cookie headers were folded into a single comma line. They are now properly preserved for seamless session tracking.

Fixed a crash that occurred when metadata headers contained emojis, accented characters, or non-Latin scripts. The SDKs now safely URL-encode all agent configuration fields.

Resolved a bug where legal URL characters were over-escaped in markdown generation. Extracted links and references now render perfectly and redirect to the correct target URLs.

Enhanced safety for concurrent data updates by validating database records immediately before committing. This prevents rare race conditions and data overwrites under high load.

Fixed an intermittent race condition that caused valid trial key requests to be incorrectly rejected with unauthorized errors, ensuring smoother testing and onboarding.

Includes several developer-experience and minor platform improvements. These include Node SDK documentation updates, optimized database locks, and proper ID-independent route caching.

We fixed a rendering conflict where forcing JavaScript execution could trigger redundant browser behaviors. Scraping requests now scale cleanly and consistently when JavaScript rendering is requested.

Fixed routing issues on the web dashboard that caused B2B demographic profiles, verifications, and stats to intermittently fail. These dashboard features are now fully functional and stable in production.

Resolved an issue where sending duplicate organization invites or triggering database conflicts would return a 500 server error. The API now correctly returns a 409 Conflict status and handles retries safely.

Fixed a task lifecycle leak where background processes in our message queue consumers could be prematurely destroyed under high load. This ensures reliable and smooth handling of asynchronous scraping jobs.

Improved data privacy by scrubbing raw exception details from telemetry logs. This prevents accidental exposure of sensitive internal runtime information in reports.

Resolved gateway vulnerabilities where crafted paths could bypass standard rate limits. All administrative and download endpoints are now strictly isolated and throttled.

Introduced a dedicated per-IP soft-blocking guard to defend against API key brute-force attacks. The system tracks cumulative authentication failures and enforces ceilings, preventing attackers from evading detection.

Enforced strict validation checks on spend-limit API endpoints for our trial key pool. This ensures trial users cannot read, modify, or delete spend-limit configurations belonging to other trial accounts.

You can now list and view your support tickets programmatically using your standard API key. This allows you to integrate support data directly into your internal tools and scripts.

High-priority requests now bypass capacity wait times during periods of peak system load. This ensures your critical tasks maintain low latency even when resource demand is high.

We have added comprehensive system font emulations to our browser engine. This makes your requests look identical to standard workstations, greatly reducing detection on highly secure sites.

The API now aligns the browser language with the target domain and proxy country automatically. This eliminates header mismatches that trigger security challenges on country-specific sites.

The API now detects target countries from multi-segment URL paths, such as language-and-country paths. This automatically routes your requests through the correct country proxy for local content.

Scraping sessions are now more stable when reusing security cookies over long periods. Improved validation prevents session identifiers from being rejected due to configuration mismatches.

Plus 12 internal improvements for better reliability and performance.

Fixed an issue where requests hitting non-empty security challenge pages failed to trigger auto-escalation. The platform now correctly detects these blocks and automatically applies retries.

Fixed a bug where the API incorrectly returned an HTTP 200 success code on browser timeouts. You will now receive the true error code so your application can accurately handle retries.

Improved our core billing gate to detect when a target page has served a security challenge or block screen. This prevents you from being charged for failed attempts on heavily protected websites.

Fixed a bug where sub-resource downloads like stylesheets or images from CDNs were missing a Referer header. The API now includes the source page as a Referer to prevent download blocks.

Fixed an issue where automatic browser escalation treated challenge screens as successful, billable scrapes. The system now recognizes these screens as blocked and triggers proper retries.

You can now stream complete bulk datasets in JSONL or CSV formats directly from your dashboard or via the API. This bypasses previous limits, providing complete, untruncated results in a single click.

Compare scraping performance across major detection systems using our new public difficulty benchmarks. You can fetch live index scores programmatically or display them with our embeddable widget.

Analyze web environments before starting a crawl with our new open-source MIT-licensed package and command-line utility. This tool cleanly identifies which system protects any given URL.

Track billing quotas, ad metrics, and job completion statistics in real time. These insights are now available programmatically and on a dedicated dashboard usage card.

Exporting large datasets is now significantly faster. We optimized our query sorting and streaming infrastructure to prevent performance degradation when traversing massive jobs.

Our scrapers now dynamically profile and mimic asset sub-resource requests. This ensures higher reliability when downloading stylesheets, fonts, and images from CDNs.

Changes to dedicated crawl environments and enterprise configs now activate instantly. This eliminates the need to coordinate manual crawler restarts or wait for redeployments.

Enterprise-level API keys created during setup now automatically receive the correct dashboard permissions. This eliminates manual configuration and prevents credential mismatches.

Plus 31 internal improvements for better reliability and performance.

Resolved a timezone bug where the first calendar day of usage data was omitted from dashboard charts. Your usage and billing history now displays fully complete periods.

Polished the visual styling of download buttons on the bulk results page. This improves layout consistency and provides clearer feedback during large exports.

Corrected a broken link on the final step of the setup sequence. New users are now seamlessly routed to the correct enterprise integration documentation page.

CSV exports are now sanitized against potential formula injection vulnerabilities. This ensures exported data is completely safe to analyze in spreadsheet tools like Excel.

You can now scale high-concurrency scraping without triggering rate limits on target domains. The API automatically regulates request velocity based on target domains and exit IP addresses to avoid blocks.

You can now leverage automated location-specific cookies for search engine scraping. This ensures regional ads and localized content are correctly retrieved and rendered based on your target country.

The scraping engine can now directly navigate to and extract text from PDF URLs. Automated browser sessions will no longer fail on automatic download triggers, returning full document content seamlessly.

We have hardened our systems to automatically identify block pages and firewalls. If a target website blocks your request, AlterLab correctly identifies the block and prevents you from being billed.

Plus 46 internal improvements for better reliability and performance.

Fixed an issue where bulk-submitted jobs occasionally returned empty results due to missing reference records. All bulk tasks now write and retrieve execution history accurately for reliable delivery.

Resolved credential authorization errors on the developer dashboard. Users can now view their billing summary and usage metrics on the billing tab without experiencing unexpected connection issues.

Fixed a bug where media assets, CDN URLs, and small-business pages failed content validation. Thresholds have been optimized to ensure thin but valid target pages are successfully returned.

We have added rate-limiting controls to all email endpoints and introduced a secure double opt-in flow for newsletter signups. This hardens our newsletter management system against automated spam.

Refined outbound browser signatures by stripping connection headers over HTTP/2. This ensures your requests are indistinguishable from organic traffic, drastically reducing blocks on secured endpoints.

Optimized our multi-tier routing logic to prevent premature escalation to premium network tiers. The system now strictly verifies page loads on standard paths first, preserving your credits.

Enforced strict processing limits on stalled web requests. Stalled jobs are now systematically terminated and released, preventing API requests from hanging indefinitely in your queue.

Improved smart routing algorithms by accurately tracking partially recovered web pages. This minimizes redundant retries, boosting overall throughput on complex domains.

Plus 35 internal improvements for better reliability and performance.

Expanded detection for interactive verification widgets to support a wider array of SDK methods. This prevents false negatives during extraction on pages using non-standard widget initializers.

Enhanced the parsing of modern JavaScript template literals inside inline script tags. The engine now avoids misinterpreting dynamic code holes as inactive comments, boosting extraction accuracy.

Corrected a parsing behavior where commented-out decoy security scripts were misidentified as active blockades. The engine now ignores inactive code, preventing unnecessary processing pauses.

Fixed a layout bug in the Developer Playground that caused the scrape results container to grow unbounded. The panel height is now capped with scrolling, streamlining the inspection flow.

Resolved an overlay hit-testing bug in the interactive tutorial that blocked clicking the 'Next' button. You can now complete playground onboarding without any UI friction.

Adds the \ service config service — the final piece of the T1-T3/T4 worker split chain ( + already merged).

Adds — a self-contained, read-only analytics script that pulls corporate-domain signups from the production DB and ranks them as social-proof landing-page candidates.

Replaces the stub Marketing Rights paragraph in §16 (Miscellaneous) of the Terms of Service with a properly-scoped Public Identity / Customer Lists clause (§16.1).

Removes the UUID label from counter, which was causing monitoring time-series cardinality blowup.

When encounters a cache SET exception (HGETALL healthy, SET fails — the partial-cache-failure scenario), it fails open and returns.

Plus 56 internal improvements for better reliability and performance.

Guards the per-job heartbeat task's done callback with a task identity check to prevent it from evicting a replacement task's dict entry in the duplicate-invocation path.

Adds a block to both socket-proxy sidecar services and updates autoheal's from to.

The root cause is a Dockerfile that is too short for the health endpoint's DB round-trip under pool contention.

Adds worker-side unit tests for the per-job liveness heartbeat write path introduced in .

Adds observability to in , which had no telemetry despite being on the dominant traffic path for the gate introduced in .

Adds three regression tests guarding the two unconditional early-return branches added by the cascade fix in ( L1247: ).

Adds wall-clock duration telemetry to the three periodic recovery sweep loops in \.

Five call sites in shared the refund idempotency key but had no corresponding NX guard on the counter decrement itself.

was called inside the gate, so circuit-breaker rejections and invalid-hostname fast-fails (both ) never touched.

Stops the mass unnecessary T4 escalation burning 7k+ T4 jobs/day at 0% success for .au liquor retail sites and .ro news sites.

Refined how browser properties, screen configurations, and automation flags are applied to our underlying environments. By matching standard property prototype behaviors, your requests successfully pass advanced structural checks that scan for automated footprints.

Fully realigned event listener structures to match standard desktop browser configurations. Advanced detection systems testing event target properties will see standard, untampered interfaces, ensuring seamless access to heavily guarded pages.

You can now initialize the MCP server automatically using a single terminal command. The CLI auto-detects your local workspace, writes configuration entries, and validates your API key.

A new integration page is available on your dashboard to guide you through connecting AlterLab to your assistant clients. This interactive walkthrough provides setup steps and API key verification.

Our browser emulation profiles now feature high-precision timers and realistic pointer simulations to mirror real user devices. This significantly improves scraping success rates on sites with advanced detection.

We resolved a routing override issue to ensure custom scraping parameters on e-commerce domains are strictly respected. This ensures highly reliable and consistent delivery of your product data.

The dashboard cost estimator now uses engine-aware pricing for search engine runs. When preparing batch or scheduled jobs, you will now see precise cost estimates that reflect actual resource consumption.

Plus 27 internal improvements for better reliability and performance.

Upgraded our graphics rendering emulation for Firefox profiles to produce natural 2D canvas text rasterization. By introducing subtle rendering variations, our browser environments avoid detection checks that seek to identify virtualized graphics hardware.

This release includes general improvements and maintenance updates.

Our integration documentation now accurately lists the full catalog of nine developer tools. This includes newly added clients and up-to-date details on session management capabilities.

You can now locate and access CrewAI integration resources directly from our sidebar navigation. This makes it simpler to find guides and build multi-agent web scraping workflows.

Search engine scraping is now faster and more reliable due to optimized session management. This prevents sudden slowdowns and ensures consistent response times under heavy query loads.

We resolved a resource allocation issue that could trigger under high request volumes. The API is now significantly more stable, preventing unexpected service interruptions during peak traffic spikes.

We fixed an API issue where requests to the unified scrape endpoint could crash with a database input error. Submitting queries with omitted template parameters now works without causing service errors.

We corrected an edgecase where failed search dispatches would incorrectly consume user balance. Failed search jobs now accurately consume zero credits, ensuring you only pay for successful requests.

We introduced a rate limit of five manual triggers per minute for scheduled search runs. This prevents parallel actions from blocking resources, ensuring consistent performance for all API consumers.

We added integer validation to pagination parameters on search schedule endpoints. Out-of-bounds or invalid formatting now returns a clear HTTP 400 error instead of causing backend processing issues.

We fixed a UI bug in the search history panel where advertiser position changes rendered inconsistently. Position changes now use unique, stable identifiers for a much smoother tracking experience.

We fixed an issue where webhook endpoints returned an incorrect HTTP 422 status on validation failure. The API now correctly returns an HTTP 400 Bad Request when rejecting a webhook destination URL.

We resolved an issue with subscription queries and improved the page-level access gating on purchase flows. Admin users can now properly toggle beta features to accurately test the user experience.

Updated our Firefox browser profiles to match the standard identity signatures of standard privacy-focused browsers. This eliminates discrepancy signals, allowing your requests to blend in naturally with standard user traffic.

Capturing screenshots during your scraping sessions is now completely invisible to advanced scripts running on target pages. Any temporary cleanup footprints left behind during the capture process are dynamically concealed, ensuring your automation remains undetected.

Successful scrapes are now guaranteed to be delivered even if a temporary connection error occurs during final billing. This prevents completed jobs from being incorrectly marked as failed.

Job records now correctly show the exact credits used upon completion. This enables you to track and analyze your API consumption in real time without reporting discrepancies.

We resolved an issue causing duplicate write conflicts for domain metrics. Diagnostic data is now consistently recorded and accessible without errors, ensuring seamless analytics monitoring.

We implemented stricter validation on keyword search prefixes to block potential server-side request forgery (SSRF) vectors. This enhances platform security by validating destination URLs before dispatch.

Added deep security hardening to isolated execution environments by automatically clearing credentials from subprocess contexts and freezing critical environment configurations. This ensures your sensitive API keys and secrets remain protected against unauthorized runtime queries.

Plus 7 internal improvements for better reliability and performance.

We have optimized retrieval strategies for cellarbrations.com.au, storefrontgateway, and images.getbento.com. This update ensures significantly higher scraping success rates on these target domains.

Our dashboard tutorial and tours have been re-sequenced to prevent overlapping elements. This ensures a cleaner, distraction-free walkthrough of our platform features.

We simplified the dashboard sidebar and mobile navigation by removing inactive tools. Keyboard shortcuts have also been reordered to help you navigate your active workspace more efficiently.

We optimized the search failover process by bypassing secondary search engines when a primary request fails. This prevents unnecessary latency spikes of two minutes or more for B2B integrations.

We optimized backend memory thresholds to support higher concurrent scraping demands. This reduces system pressure and prevents unexpected drops during high-volume scraping tasks.

We have completely removed deprecated sidebar items, tour steps, and help references. This streamlines your workspace, allowing you to navigate your dashboard faster and with zero clutter.

We resolved a critical routing issue on Adidas API endpoints, restoring success rates to 100%. Your requests on these paths will now execute smoothly and avoid detection systems automatically.

We fixed flow errors in our deposit system that previously led to silent transaction failures. Users will now receive clear, immediate feedback if a payment verification step requires attention.

We resolved an issue where requests for specific domains, such as Metacritic and Geizhals, timed out. These requests will now properly fall back to asynchronous execution with real-time status feedback.

We resolved a conflict where the welcome modal and onboarding tour opened simultaneously, blocking dashboard interaction. The tour now starts only after you dismiss the welcome screen.

We added exact cooldown countdowns to error messages shown when you cancel a payment challenge. Instead of a vague warning, you now know exactly when it is safe to retry your deposit.

We upgraded our backend connection layer to proactively prevent transient errors during high-volume query spikes. This ensures your API requests remain highly stable and completely uninterrupted.

We resolved a background rendering issue on our developer blog pages that could cause sporadic loading slow downs. Articles now load instantly and reliably.

We resolved a significant connection issue affecting requests to major Australian retail platforms. Scraping success rates on these targeted domains have been vastly improved.

Fixed an issue where Google Shopping ads were occasionally dropped from search engine results pages. You will now receive complete, uninterrupted shopping ad data in your API payloads.

Fixed a compatibility issue where certain non-default browser environments could trigger security blocks. This update ensures seamless detection avoidance regardless of your browser configuration.

Succeeded quick deposits with saved cards now complete without error. Your balance will update instantly, and payments will process smoothly.

We have removed the inactive Crawl and Map links from the dashboard navigation panel. This eliminates unnecessary visual clutter and helps you focus on your active web scraping workflows.

Scrape requests requiring intensive execution are now automatically routed to our asynchronous system. Instead of waiting on a slow connection, you will immediately receive a job ID for polling.

European and UK users can now complete quick dashboard deposits seamlessly using native multi-factor 3DS verification. This eliminates manual payment retries with different cards.

Standard and lightweight target sites can now support significantly higher parallel requests. This allows you to scale up your data retrieval pipelines and speed up bulk scraping.

We scaled up our core API gateway capacity to handle double the standard concurrent workload. This minimizes request queue times and guarantees stable performance during traffic spikes.

Our request engine has been updated to mimic the latest browser connection patterns and headers. This ensures reliable access on domains guarded by advanced website detection systems.

We improved scraping reliability and resolved consistent blocks on several major retail, media, and e-commerce websites. These targets are now fully operational with preconfigured parameters.

All ledger balances, subscription start/end dates, and payment history records now accurately reflect the correct UTC timezone. This ensures perfect alignment in your billing history views.

The trial playground now offers descriptive error states when test scrapes reach the execution time limit. This helps you identify how to properly configure your scraper settings before launch.

This release also includes minor fixes to the account balance auto-refresh system and database optimizations for transaction processing. These improvements ensure a smoother dashboard experience.

Returning customers with a saved payment method can now top up their balance instantly without leaving the platform. This new quick-deposit widget on your billing dashboard completes payments in under two seconds.

You can now access a guided onboarding tour that highlights critical platform workflows right inside your workspace. This step-by-step assistant ensures a smooth learning curve as you explore our scraping tools.

We combined profile and balance requests into a single startup payload and parallelized query execution. This eliminates round-trips and reduces dashboard load time by up to a second.

We updated our routing patterns to ensure seamless data extraction from major entertainment and review platforms, including Metacritic. Requests to these domains now reliably bypass strict network defenses.

We replaced jarring placeholder states and empty charts with smooth, pulsing skeleton loaders during initial startup. Your actual usage metrics and balance figures now appear seamlessly once fully loaded.

Plus 12 internal improvements for better reliability and performance.

We added direct sidebar navigation links for crawling, mapping, and executing workflow actions. This change allows you to jump directly into different tools without extra steps.

We simplified onboarding to get you scraping faster by removing a redundant setup screen. After generating your API key, you are taken straight to the playground to run your first scrape.

Resolved an issue where high-volume, simultaneous account top-ups could occasionally fail with server errors after successful payment. Balance updates are now processed reliably under heavy concurrent load.

Fixed a bug where failed deposit attempts due to non-card billing issues would get permanently stuck in a "pending" state. Your billing history now immediately and accurately reflects these events.

Fixed an internal database driver issue that caused PDF invoice downloads to fail with server errors. You can now download all historical and current billing statements from your portal without interruption.

Corrected broken links in auto-recharge and transaction notification emails. All links now direct you straight to your active billing dashboard page instead of returning a non-existent page error.

Fixed a rendering bug in our system notification templates that could suppress important links and relevance details. This ensures all system update emails arrive complete and fully formatted.

Resolved a page rendering crash that could affect first-time visitors loading the home page. Additionally, we updated security headers to ensure strict compliance with Content Security Policies.

Fixed a database lock contention issue that could occasionally cause analytical logs or domain-specific request metrics to fail to record. Your scraping statistics are now completely consistent.

Fixed a routing escalation issue to ensure strict compliance with your account's maximum tier and cost policies. The system now correctly respects and enforces your cost limits on protected domains.

Enterprise members accepting invitations now land directly on their organization dashboard. This prevents incorrect routing to personal accounts and avoids confusing consumer credit prompts.

We have launched a self-service dashboard tailored specifically for enterprise clients. You can now manage your custom data pipelines and delivery destinations directly from a modern, unified interface.

A new standalone card displays all historical invoices and receipts directly on your billing dashboard. You can now quickly view payments and download PDF copies without navigating nested tabs.

Enjoy faster and more reliable data extraction on Dutch news domains. We optimized our routing logic to use more efficient connection profiles, achieving over a 97% success rate.

Our API now employs smarter routing limits for websites protected by advanced detection challenges. This prevents unnecessary escalation to premium routing tiers while maintaining high success rates.

Scraping international Adidas domains is now much more reliable. We resolved routing conflicts and updated outdated detection hints, ensuring your requests succeed instead of getting blocked.

The API now returns a 503 status code with a standard Retry-After header during temporary system maintenance. This allows your integration to gracefully handle brief interruptions with automated retries.

Authenticated users visiting the public playground are now automatically redirected to the dashboard. This ensures you do not run into public rate limits and can test in your own sandbox.

Plus 9 internal improvements for better reliability and performance.

If a target flags an IP during initial attempts, the API now assigns a fresh IP for the fallback request. This avoids inherited blocks and boosts success rates on tough domains.

Our request engine now dynamically manages domains with advanced protection to save your account credits. The system automatically shifts scraping modes to optimize success while reducing execution cost.

We have migrated our domain validation checks to utilize asynchronous resolving methods. This prevents background latency spikes and improves API response times under high concurrent request volumes.

We upgraded internal links on the delivery dashboards to utilize framework-native routing protocols. This eliminates full page refreshes, providing a faster and more responsive browsing experience.

All announcement, campaign, and weekly digest updates have been migrated to our modern design system. You will now receive beautiful, responsive emails that look great on any device.

We have enabled full synchronization for transaction and account events, restoring missing notifications for auto-recharge and payment updates. This ensures you never miss a critical alert.

We now automatically block setting up auto-recharge with one-time payment methods like Klarna, Affirm, and cryptocurrency. This prevents invalid billing configurations.

Resolved an issue where asynchronous responses incorrectly returned null values for destination URLs and redirect chains. You will now reliably receive the complete redirect path for all requests.

Fixed an issue where clicking the "Get Started Free" button in the navigation header did not trigger any action. The button now correctly launches the registration dialog without issues.

We've added support for timing-gate APIs used by advanced verification challenges. This prevents script crashes and allows the browser environment to accurately simulate real-user execution.

The scraping environment now supports standard text-encoding and decoding APIs. This ensures that verification scripts processing complex encoded tokens run successfully without throwing errors.

We've implemented support for cryptographic hashing verification APIs on target pages. Scraping requests on sites requiring background mathematical computations will now succeed far more reliably.

API responses now accurately populate the final destination URL and the complete redirect chain across all scraping modes. This allows you to track programmatic redirects without writing custom middleware.

Improved the organization acceptance flow to ensure invitation tokens are only consumed upon a successful database commit. This prevents accidental user lockouts during registration bottlenecks.

We added a protection guard that prevents active user credentials from being overwritten if invitation links are reused. The system now returns a conflict response to secure existing accounts.

Fixed an issue that caused intermittent server errors when accessing invoices from direct links. Customers can now reliably retrieve and download PDF records of their payment history.

Fixed a visual glitch on the overview page that incorrectly labeled active webhook destinations as unconfigured. The interface now accurately represents your custom data export destinations.

Receive immediate email notifications if auto-recharge is disabled due to an expired or detached card. This ensures your scraping tasks are never silently interrupted by billing issues.

Fixed an issue where recently added payment methods were missing from your billing dashboard. All active payment methods are now properly synced and manageable directly from your account.

The platform now detects target site block pages even when they are served with a standard success status code. This prevents empty block pages from consuming your scraping quota.

Restricted raw exception details from being returned when verifying cloud storage configurations. This guarantees internal metadata and provider details are never exposed in standard API responses.

We have strengthened security checks for data delivery destinations, proxy setups, and webhook endpoints. This blocks domain-rebinding attacks to keep your data transfer channels secure.

We have tightened API key authorization controls to ensure self-serve access profiles are strictly isolated from high-volume corporate routes. This prevents accidental credential misconfiguration.

System notification messages now thoroughly sanitize account and organization names of control characters. This protects automated billing and usage alerts from email manipulation risks.

We have blocked local IP addresses and local hostnames from leaking through WebRTC connection requests. This prevents target websites from discovering your network details.

Connection latency and speed characteristics are now randomized across requests. This prevents target detection systems from tracking you using static network profiles.

Headless browser configurations now accurately emulate standard browser PDF viewer behaviors. This eliminates a common browser compatibility inconsistency that detection systems use to block requests.

Implemented synchronous script injection within child iframes, closing a timing gap where target page checks could execute before our anti-detection modifications were applied.

You can now view the unblurred raw output of your first scrape in the sandbox playground. This lets you inspect the precision and structure of the returned data instantly before signing up.

The system now handles rate limits with an automatic backoff instead of immediate escalation to browser-based tiers. This preserves your high-performance credits and reduces billing costs.

The browser-rendering tier now automatically rotates proxies and retries on transient errors or timeouts. This significantly increases success rates on highly protected sites.

Billing emails now deliver invoice documents as secure, first-party static PDFs rather than dynamic third-party views. This ensures documents load instantly inside all secure email clients.

Our routing engine now skips browser-specific checks entirely when bypassing rendering execution. This reduces handshaking overhead and accelerates response times for static-content scrapes.

Our AI selector and schema generation engine is now hardened against premature output truncation. It parses complex page layouts with nested formatting robustly, while protecting output integrity.

Plus 32 internal improvements for better reliability and performance.

Our request evaluation prioritizes block screens over interactive challenges from detection systems. This ensures consistent handling and highly accurate error reporting during scraping tasks.

We have introduced detailed background logging for session baseline failures. This improves troubleshooting for edge-case connection drops and helps resolve scraping issues much faster.

Temporary network disruptions, such as connection resets, are now properly retried instead of being treated as permanent failures. This greatly increases success rates for large-scale jobs.

The queue now respects backoff delays before retrying rate-limited requests instead of re-enqueuing them immediately. This maximizes success rates and avoids wasting your retry budget.

The request engine now prioritizes block page checks before launching challenge solvers. This prevents the scraper from misclassifying block pages and ensures smarter automated recovery.

Browser engine retries now strictly respect your remaining timeout budget. The engine will fail-fast if a crash happens near your limit, returning responses sooner instead of starting a new session.

We aligned client and backend password validation rules. The signup and settings forms now correctly enforce the 10-character minimum (with a letter and digit), preventing unexpected errors.

You can now query your API usage using standard API keys instead of bearer tokens. This resolves authentication issues during integration tests on external automation platforms.

The interactive sandbox now correctly reveals scraped content on your first successful attempt, even if earlier attempts failed. This ensures successful previews are immediately visible.

Billing invoice downloads are now pinned to the correct document type so your browser can open them immediately. This prevents files from being misidentified or downloaded with incorrect formats.

We added strict protocol checks to verify all payment invoice references over secure HTTPS connections before retrieval. This enhances transactional safety and prevents unencrypted fetches.

We updated all inline scripts on our homepage to enforce per-request cryptographic nonces, aligning fully with strict Content Security Policy guidelines to prevent cross-site execution.

You can now globally opt out of non-critical transactional and account emails directly from your preferences. This gives you full control over which notifications reach your inbox.

We added native support for machine-initiated unsubscribe requests. Email clients like Gmail can now unsubscribe you in one click without executing front-end code.

We optimized our database query pathway for opt-out lookups, achieving up to a 25x reduction in latency. This ensures that your system and verification emails are dispatched almost instantaneously.

Critical organization and security notifications now bypass global opt-out settings. This ensures you never miss vital security updates, member invitations, or ownership transfers.

One-click unsubscribe headers are now consistently preserved and sent across fallback email channels. This guarantees a seamless unsubscribe experience regardless of the delivery path used.

We restored fail-fast backpressure mechanisms for background task workers during peak usage. This prevents resource exhaustion and ensures high-volume scraping tasks execute with high stability.

We unified our block-handling logic into a vendor-agnostic escalation policy. This allows your scraper requests to gracefully adapt when encountering aggressive target detection systems.

Plus 58 internal improvements for better reliability and performance.

We resolved duplicate rate-limit checks and corrected client IP forwarding. This ensures that legitimate unsubscribe requests are not falsely blocked by shared rate-limit buckets.

Added an automated request timeout to our unsubscribe proxy handler. This prevents slow backend responses from hanging or stalling your browser session indefinitely.

Fixed a bug where unsubscribe links in lifecycle emails rendered raw template variables instead of the actual signed URL. Unsubscribe links in all automated emails are now fully functional.

Fixed a visual reporting bug where automated email metrics were permanently stuck in a queued status in the dashboard. Delivery status now updates accurately to reflect successful dispatches.

Fixed an issue where daily email send limits failed open during temporary database disruptions. Daily send caps are now securely maintained and enforced under all conditions.

We removed insecure client IP fallbacks across authentication and proxy handlers, relying strictly on trusted, unspoofable headers. This prevents IP-spoofing attacks on sensitive endpoints.

We hardened authentication pathways against potential timing side-channel attacks by implementing constant-time token verification. We also resolved an exception triggered by non-ASCII headers.

We added explicit newline stripping to custom email headers to prevent carriage return/line feed injection. This hardens our transactional email system against malicious header manipulation.

Earn recurring commissions by promoting AlterLab through our new dashboard interface. You can now track referrals, view your payment history, and build promotional links directly in one place.

Invite fellow developers to try our platform and get rewarded. Both you and the referred user will receive $0.50 in free API credits once their new account is successfully created.

The scraper now automatically queries alternative structured endpoints (like WordPress REST or GraphQL) when HTML extraction fails. This fetches structured data directly, avoiding slow browser rendering.

We have introduced fully automated solving for pages protected by reCAPTCHA and hCaptcha. The platform dynamically extracts site keys, solves the challenges, and returns the protected content.

The platform now securely evaluates inline scripts to capture dynamic client-side application states from server-rendered pages. This allows you to retrieve fully computed data structures.

Easily migrate your existing pipelines to AlterLab with zero code changes. We now support drop-in SDK compatibility with other popular scraping tools, complete with quick-start guides.

We optimized our llms.txt and OpenAPI schema specifically for AI grounding. Large language models can now reason about, integrate, and call our API with higher success rates.

Generate and test your credentials faster than ever. When you create an API key in our onboarding modal, a silent background scraping demo is initiated so you can inspect live data immediately.

Plus 27 internal improvements for better reliability and performance.

For proven server-side rendered targets, requests are routed directly to the optimal execution layer. This completely bypasses initial probe latency, saving up to 5 seconds per request.

We updated the challenge solver initialization sequence to strictly attach before target scripts run. This eliminates race conditions and ensures browser overrides are fully applied.

A direct billing link is now included in all HTTP 402 responses. This allows developers to quickly access the payment page and resolve balance limits directly from their error logs.

Modified routing to automatically attempt browser-based rendering when targets have incomplete SSL chains. Rather than failing, the system attempts alternative secure retrieval paths.

Aligned browser user-agent headers with network signatures to match standard browser updates. This reduces detection rates on targets that verify version consistency across connections.

Our request routing now detects empty shells or verification screens returned by target site protection systems. The API automatically escalates and retries the request to ensure success.

We improved simulated browser behavior on major localized online storefronts. Sessions now reliably execute human-like cues to bypass blocks and increase success rates.

Your dashboard now falls back to displaying the target domain name for historical scraping jobs. This preserves high-level URL visibility in your history even after underlying payload data is cleared.

Fixed a backend query constraint error that caused the support tickets list to crash for any accounts that had multiple active tickets. Users can now view their full support history without issues.

Introduced database-level safeguards to eliminate double-counting on affiliate commission records. This ensures that brief network retries from payment processors are safely ignored.

The \ parameter in the unified scrape endpoint looked up templates by slug without filtering on \.

Guards affiliate commission in the legacy one-time payment path behind the success result, preventing affiliates from earning commission when credits were never actually granted.

Fixed an issue where jobs interrupted by crawler restarts could remain pending indefinitely. Interrupted job states are now fully synchronized, ensuring you receive clear failure reasons.

Crawl-related validation failures are now parsed into human-readable error messages. This prevents raw, nested response structures from causing interface rendering crashes.

Fixed connection edge cases in the challenge solver that could cause premature aborts. The solver now reliably triggers browser-level fallbacks whenever verification challenges arise.

Secured our specialized B2B demo environments behind secure session gates. These pages now require active user authentication to prevent unauthorized public access or relationship exposure.

We hardened search endpoint error handling to prevent the exposure of account balance details in standard error responses. Failed transactions now return clean, generic responses.

## Milestone: Landing Page Redesign.

Plus 11 internal improvements for better reliability and performance.

Fixes two minor review findings from :.

Implements the missing scrape probe in.

- Terminal fullscreen overlay was rendered inline in the React tree, trapped inside by creating a containing block.

- : Removed from page root div.

Renames the misleading domain slug to so correctly serves Reuters content instead of the confusing URL.

- returned (0% uptime) when was missing (first run), triggering a spurious SLA breach alert.

The dockerd self-health check in 6 monitoring scripts interpolates directly into a raw curl JSON body string.

- Stop infinite retry loop in session recording when session creation fails with 4xx.

internal service's daily SEO blog batch hits and crashes with 500 ( unique constraint violation).

cloud provider worker containers expose domain-level metrics via but had no scrape targets for them — only the Netcup Pushgateway was collected, leaving cloud provider fleet data absent from Grafana dashboards.

Fixes jq injection vulnerability where and were shell-interpolated directly into jq program strings in.

Corrects the Grafana unit label on the **\"Wasted Compute Rate (sec/min) — by Tier\"** panel in the Scraping Engine dashboard.

- Catch and in monitoring system's entry point to prevent infinite crash-looping when Discord resets the bot token.

Our data extraction pipeline now features dynamic model routing and failover support. If an AI model experiences downtime, the system automatically redirects requests to ensure uninterrupted service.

Initial page loads for technical resources are now up to 30 seconds faster due to optimized server pre-rendering. This ensures you get the integration guides you need instantly.

We synchronized browser profiles across all scraping modules to prevent signature mismatch flags. This increases your extraction success rates and bypasses advanced target detection systems.

Internal navigation throughout the developer documentation is now completely fluid. You can jump between setup instructions and quickstart guides without triggering full page reloads.

Plus 10 internal improvements for better reliability and performance.

We optimized rendering on the web dashboard to eliminate animation lags during page transitions. This makes navigation and dashboard updates feel significantly faster and more responsive.

We have added a prominent retry button to our billing page if you abandon a payment session. You can now instantly resume your checkout and retry the payment with a single click.

We prevented the sign-in modal from being closed accidentally by clicking outside the form or hitting Escape. This keeps you focused on your login or onboarding flow without losing state.

If you cancel or exit during checkout, you are now greeted with a helpful recovery banner. This provides a direct path to retry your billing action or seek assistance.

We corrected the routing on our pricing comparison blocks to ensure new users are directed to registration instead of sign-in. This guarantees a smoother onboarding path when choosing a plan.

We fixed a temporary parsing failure caused by a deprecated third-party AI model on our free tier. The system was updated to a newer active model to maintain consistent extraction stability.

We eliminated the brief flash of light that occurred when loading the developer dashboard in dark mode. The platform now renders dark themes server-side for an eye-friendly loading experience.

Saving a new card now successfully persists the payment details to your billing profile. Previously, card setup would report success but fail to actually save the card to your account.

Admin API requests using standard Bearer tokens are no longer incorrectly blocked. You can now reliably run scripts and automation tools using only standard token authentication.

Your saved payment methods are now properly recognized and displayed at the top of the payment form when adding funds. You no longer need to re-enter your billing information during Stripe Checkout.

We fixed an issue that caused intermittent server errors when responding to support tickets. Ticket updates and replies are now processed reliably and delivered without interruption.

Test URLs on our homepage and instantly open your extraction results in the playground with a single click. This lets you inspect full results, experiment with configurations, and export code without restarting your scrape.

One-click sandbox testing is now built directly into our technical guides. You can launch blog post code examples straight into the interactive developer playground, pre-configured and ready to run.

This release includes general improvements and maintenance updates.

Plus 9 internal improvements for better reliability and performance.

The Node SDK now includes full TypeScript support for the engine selection parameter in both single and batch search requests. Developers can now build programmatic queries with complete type safety and editor autocomplete.

Our AI-assisted extraction pipeline now supports robust fallback model routing. If your primary AI model encounters rate limits, the system seamlessly cascades to your fallback model to prevent job interruptions.

We have simplified our pricing page to highlight our Smart Router benefits and clear up plan selection. A streamlined navigation experience makes it easier to evaluate options and find the perfect tier.

Your API credits are now protected from invalid webhooks. Balance debit logic runs after webhook destination validation, ensuring credits are never charged if a webhook URL fails initial checks.

- Add to all grep pipelines in feature-flag validation and monitoring config sections.

Guarantees billing integrity for batch search engine queries by automatically refunding credits for unsuccessful, expired, or failed tasks. You will only be billed for successfully completed search jobs.

Ensures correct session and IP rotation triggers are reached during health checks. This guarantees consistent evasion of detection systems and significantly higher success rates for long-running scraper tasks.

Resolves a timeout conflict where CAPTCHA solving challenges were prematurely cancelled during parallel dispatches. CAPTCHA routines now have sufficient time to complete, boosting success rates on protected pages.

Fixes a queue routing error where search engine query jobs could be processed by generic workers lacking the required session context. Jobs are now correctly pinned to matching worker queues.

Includes several stability improvements across our platform. We resolved unreachable administrative endpoints, fixed JWT authentication errors, and corrected playground cost calculation inaccuracies.

Introduces atomic slot-claiming in our session pools to ensure absolute user isolation. This guarantees concurrent users never share browser profiles, active cookies, or session histories.

Hardens internal network security with robust Server-Side Request Forgery validation. Additional checks protect custom storage configurations and background webhook tasks from unauthorized requests.

You can now find clearer definitions and standard terminology across our public glossary and documentation. This makes it easier to understand platform features and configure automated integrations.

Plus 4 internal improvements for better reliability and performance.

You will experience more reliable API connectivity and routing stability with resolved forwarding timeouts. Scraping workloads now benefit from optimized requests and consistent uptime.

Deletes — dead code targeting the decommissioned E2E server ([server]).

Fixes two wrong load balancer API endpoint URLs in.

All 13 psql callsites in hardcoded.

Smoke tests validated containers directly (via into the API/web containers), not through load balancer routing.

- Adds pass-through to both and.

Trivy worker image scan was failing with when decompressing container layers into on ubuntu-latest GHA runners.

Get a one-time 25% extra credit on your first balance deposit. If your deposit also qualifies for a volume bonus, we automatically apply the higher of the two to maximize your credit.

Receive early email notifications if your account's usage speed projects balance depletion within three days. This proactive system helps you replenish your funds before active scraping tasks are paused.

A clear, dismissible warning banner now appears in your dashboard when your balance drops below $2.00. This provides a visual cue to top up your account and prevent unexpected service pauses.

Added a live success and latency metrics table for 20 top target domains. You can now easily identify the optimal plan tier and cost-per-request for your specific targets.

After verifying your email address with a one-time passcode, you are now automatically logged into the platform. This removes the redundant step of entering your credentials a second time.

We have updated our browser emulation layer to more naturally handle page state and visibility changes. This ensures that advanced detection systems cannot flag automated sessions on interactive sites.

Support chats now feature clear color differentiation between your messages and admin replies. This layout update makes long conversation histories much easier to scan, track, and read.

The interactive onboarding flow has been upgraded to target a dedicated, structured test site rather than a static placeholder. This provides a realistic demonstration of our data parsing capabilities.

Platform emails now display a clear, branded sender name instead of a plain address. This ensures that critical billing alerts and account notifications are instantly recognizable in your inbox.

Plus 27 internal improvements for better reliability and performance.

The maximum scrape request duration limit has been raised to 210 seconds. This prevents unexpected timeout errors on slow-loading targets, ensuring complex scraping tasks complete.

We improved timing synchronization when waiting for specific page elements to load. Scrapers will now experience cleaner execution with reduced timing conflicts and fewer uncaught timeout warnings.

Resolved a styling issue where support replies and chat bubbles rendered unreadably in light mode. Text now dynamically adapts to your theme, ensuring optimal legibility across all layouts.

Fixed a layout bug where the registration page displayed a sign-in heading even when accessed from sign-up buttons. This provides a clearer and less confusing sign-up process for new users.

Fixed an issue where uploading screenshots and files to support tickets could fail. You can now reliably attach files to your tickets to provide full context on your inquiries.

We established a minimum timeout floor for page navigation under low remaining time budgets. Scrapes on sites without specialized rules will no longer fail prematurely during execution.

The system now automatically recovers transaction data if a database timeout occurs during deposit processing. This ensures your 25% first-deposit promotional bonus is always credited.

We corrected a calculation error in the credit limit warning system. Free grants and welcome credits are now processed accurately, preventing premature or incorrect limit notifications.

Fixed an issue where network interruptions or outdated browser assets caused the dashboard to freeze. The application now auto-recovers and reloads automatically to restore service.

Resolved a directory permission error that caused some file uploads to fail on the support page. You can now attach logs, screenshots, and other diagnostic files to your support tickets.

Fixed an issue that caused sender email addresses on system notifications to appear with duplicate formatting. System emails now display sender names clearly across all inbox clients.

We have strengthened validation on dashboard redirect URLs to reject unsafe protocol-relative links. This security reinforcement protects your active sessions from open redirection attempts.

We applied a security limit of 30 requests per minute to the session token exchange endpoint. This matches existing safeguards to protect user accounts and prevent credential abuse.

Attach files directly to your support tickets using drag-and-drop, file browsing, or clipboard pasting. Attached files are rendered inline as clickable thumbnails or download cards.

Experience real-time support updates on the dashboard with instant notifications, typing indicators, and live toast alerts. Ticket unread badges ensure you never miss an update.

We have introduced a full Markdown editor for ticket replies, complete with formatting shortcuts and live preview. Writing and formatting technical support tickets is now faster and more intuitive.

Deduplicated DNS lookups during batch URL operations to prevent sequential blocking network bottlenecks. Requests targeting multiple URLs on the same domains now process significantly faster.

Increased the maximum wait time for client-side rendered (CSR) or complex Single Page Applications (SPAs) from 10 to 20 seconds. This allows slow dynamic content to fully hydrate before capture.

We have significantly upgraded our browser emulation layers to perfectly simulate standard desktop environments. Visibility, screen dimensions, focus, and permissions now match real user behaviors to prevent detection.

Each individual scrape request now utilizes completely isolated cookie jars and browser contexts to eliminate cookie leakage. This prevents security filters from tracking request patterns across different targets.

Standard requests are now dynamically isolated from high-reputation IP pools reserved for protected targets. In addition, temporary proxy blocks now decay gradually on success, keeping the active IP pool healthier.

Our request pipeline now executes a unified challenge detector before evaluating a page's content template. This ensures challenges hidden within styled, realistic-looking pages are correctly identified and resolved.

We have expanded our automated challenge solvers to natively support a wider range of verification networks. Our background solvers are optimized to continue instantly upon verification, reducing request latency.

The API now dynamically manages intermediate timeouts during multi-tier rendering attempts. If an initial attempt encounters delays, your remaining execution budget is preserved for high-success browser rendering.

The background execution environment has been hardened against syntax errors and unsafe injection patterns. This significantly reduces warning alerts and improves extraction success rates on complex websites.

Browser instances in the automation pool are now automatically rotated after visiting a set number of unique domains. This clears accumulated state and prevents cross-domain tracking.

Plus 18 internal improvements for better reliability and performance.

Enhanced our underlying block recognition patterns to catch empty or structured blocking responses from advanced security walls. The API now flags these attempts instantly, allowing for faster retries.

Fixed an issue in async webhook payloads where minor URL variations incorrectly triggered a redirected flag. The system now normalizes URLs before comparison for highly accurate reporting.

Fine-tuned our soft-block classifiers to prevent false-positive flags on legitimate, text-light websites like simple landing pages. Your scraping pipelines will experience fewer erroneous blocks.

Resolved a routing discrepancy that caused async-path domains to occasionally experience elevated block rates due to profile constraints. Routing has been optimized to ensure consistent scraping runs.

Fixed minor UI bugs in the dashboard playground, including persistent redirect chains across result views. We also eliminated double-submission issues when closing or muting support tickets.

We resolved multiple dashboard bugs, including a truncation issue that capped the unread ticket badge for active accounts. Inactive tickets are now closed accurately based on their grace period.

The interactive API playground results panel has been updated to use a consistent height matching the configuration column. This resolves layout shifting issues, making it much easier to test your parameters.

Hardened Markdown rendering and email pipelines to block potential cross-site scripting (XSS) and header-injection attempts. Malicious links and payloads are now neutralized automatically.

The user dashboard now enforces a strict URL protocol allowlist on all clickable notification actions. This prevents unexpected protocol executions, ensuring a safe browsing experience.

You can now manage your support email preferences and mute individual tickets directly from the dashboard settings. This gives you complete control over which ticket updates and notifications reach your inbox.

API scrape results now include a detailed record of the redirect path taken to reach the final page. You can now inspect every individual hop and status code directly in your responses.