Changelog

Plus 3 internal improvements for better reliability and performance.

API requests for batch job statuses now return descriptive error messages instead of server errors when an item fails. This ensures your integration can gracefully handle scraping failures without interruptions.

We have introduced automated checks to detect and resolve data inconsistencies before they impact your billing or account access. These improvements harden our systems against unexpected interruptions, keeping your operations running smoothly.

The platform now periodically tests alternative scraping approaches for domains you frequently request. This breaks out of suboptimal patterns and automatically discovers faster, more reliable strategies over time.

When browser-based scraping capacity is under heavy load, requests are now intelligently routed to lighter processing methods instead of queuing. This reduces wait times and improves throughput during peak periods.

- Creates `services/api/app/services/stripe_notifications.

- 10 review findings from validated and fixed across the milestone branch.

Experience a completely redesigned dashboard for managing your scraping operations. The new interface provides better visibility into your account and simplifies common administrative tasks.

You can now target 195 different countries for localized scraping results, ensuring accurate data from virtually any region. This includes new priority regions for more precise fingerprinting and geo-targeting.

The system now refreshes its domain performance data more frequently, allowing it to respond to site changes within days rather than months. Your requests benefit from up-to-date routing decisions.

Plus 10 internal improvements for better reliability and performance.

We improved the reliability and speed of stealth execution by preventing redundant script injections. This leads to faster page loads and more consistent success rates on high-security targets.

Our search engine parsing logic now more accurately distinguishes between advertisements and legitimate content. This prevents false positives and ensures cleaner data delivery for your analysis.

You now have clearer control over forcing requests to specific performance tiers, whether you need higher capabilities or want to optimize for cost. This gives you more granular control over how your resources are utilized.

System recovery processes are now significantly faster thanks to optimized database query patterns. This reduces downtime and ensures your jobs are resumed more quickly after maintenance.

Platform updates now feature significantly reduced connection interruptions for critical stateful services. You will experience smoother transitions and higher availability during our routine platform maintenance.

The API reference now includes dedicated sections for authentication, scraping workflows, and session management. These updates provide clearer guidance for integrating core platform features.

Infrastructure-related failures are now tracked separately from site-level blocks. This prevents temporary server issues from incorrectly influencing the platform's strategy choices for future requests.

Performance data is now tracked independently for each subdomain. A single high-traffic subdomain can no longer skew the strategy used for other subdomains on the same root domain.

Crawl-mode requests now benefit from the same adaptive exploration and capacity-aware routing as standard requests. This closes a gap where bulk crawling could get stuck using suboptimal strategies.

py` to filter DuckDuckGo ad/tracking URLs (`duckduckgo.

The budget is enforced via an atomic Redis INCR counter (`AI engine:gemini:calls_today`) that expires at midnight UTC.

`SearchRequest` and `BatchSearchRequest` had no `model_config`, so Pydantic v2 used its default `extra="ignore"` — unknown fields like `domain_filter` were silently dropped instead of returning a vali.

- Added empty-context guard: `OutputQualityAgent.

Adds a Redis circuit-breaker to `BaseAgent.

Antibot failure rate was computed as `antibot_fail / t_total` where `t_total` includes infra failures.

- Fixes the alerts page 422 storm: every ~500ms poll was failing because the frontend sent a full ISO datetime but the backend only accepted `date` type.

Zero-event sessions (61% of all sessions) showed a blank white rectangle in the replay player with no feedback.

With 9+ worker replicas, any replica dropping below the 80% utilisation threshold was clearing the global `worker:browser:saturated` key — neutralizing the backpressure signal while other replicas rem.

rrweb full DOM snapshot events (type 2) are routinely 20–200KB but the per-event validator was capped at 10KB, causing 61% of sessions to receive zero events.

Replace `except (ValueError, Exception):` with `except ValueError:` in `_BlankListEnvSource.

- `services/worker/worker/consumers/unified_consumer.

The web container was logging ~8 `[PG Pool] Unexpected error on idle client: terminating connection due to idle-session timeout` errors/hour (384 in 48h).

Zoho OAuth token refresh fails silently when the refresh token is expired/revoked.

Waiters should be woken then, not after close I/O completes.

Mirrors 7 browser session management env vars from `.

Derives DB pool overflow alert thresholds from the actual `max_overflow` pool config instead of hardcoded constants.

code` when a promo was applied.

Decrement the Gemini daily call counter when a call is rejected for exceeding the budget limit.

Discord webhook URLs embed a secret token as the final URL path segment.

Add soft-delete filter to the `event_chunks` query in `export_session`.

The extraction template field is now fully restored for crawl requests in the Node SDK. This ensures consistency across all request types and simplifies template-based data extraction.

The default crawl depth strategy has been restored to its intended sequential behavior. This ensures your crawl jobs follow a predictable path and resource usage aligns with your configurations.

Manual feedback triggers now bypass internal activity filters, ensuring that even low-volume domains receive immediate analysis. Your input will always be processed regardless of recent traffic levels.

We corrected a data filtering issue in the usage dashboard to ensure performance insights are accurately reported. You can now rely on precise metrics when analyzing resource limits and success rates.

You can now use bearer token authentication to securely integrate your external monitoring tools with our metrics endpoint. This eliminates the need for complex network allowlists while keeping your data protected.

We have implemented a gradual rollout system for all service updates to ensure maximum platform stability. This reduces the risk of interruptions by validating changes before they reach all users.

The internal queueing system has been optimized to handle larger bursts of scraping requests without data loss. This ensures your high-volume tasks are processed reliably even during peak periods.

Our system now performs more frequent health checks to monitor API availability during infrastructure changes. This allows for faster detection and resolution of minor service disruptions.

Plus 13 internal improvements for better reliability and performance.

The API now correctly identifies and processes PDF and image URLs when using the automatic routing mode. You will no longer encounter errors when sending these file types for processing.

We resolved an issue that could prevent the successful recovery of interrupted scraping tasks. This improvement ensures that your jobs are correctly managed and completed if a system restart occurs.

The API now correctly identifies and routes PDF and image URLs when using automatic detection mode. This prevents the system from defaulting to standard web scraping, ensuring you receive the correct data format every time.

The interactive demo has been updated to correctly handle automatic mode upgrades for specialized content. Your testing experience in the demo environment now accurately reflects the behavior and performance of the production API.

Estimated usage metrics now correctly reflect requests that are automatically upgraded to specialized processing modes. This fix ensures that your usage logs provide a transparent and reliable view of your account activity.

Code samples generated in the playground now use the correct request structure for performance and cost controls. You can copy and paste code directly into your application without needing to manually adjust the JSON structure.

We have improved our ability to detect error pages that return a successful status code. This ensures that blocked requests are correctly identified and handled, leading to higher success rates and cleaner data.

The estimation endpoint now correctly accounts for your requested performance tier overrides. This allows for more precise budget planning and usage tracking when using advanced scraping options.

Cached results are now separated by your requested performance settings to prevent data inconsistencies. You will always receive the data quality corresponding to your specific request parameters.

The API now strictly enforces your requested performance level and will no longer silently downgrade requests. You can be confident that every request is executed with the exact resources and routing you specified.

Custom options such as proxy settings and screenshots are now fully supported in PDF and OCR modes. This provides greater flexibility and control when generating documents or extracting text from complex files.

Scraping in HTML mode now fully respects all job configurations, including proxy and performance settings. This ensures your custom requirements are applied consistently across every scraping method we offer.

We have implemented an advanced multi-tier isolation system that significantly reduces session overhead. Your scrapes are now faster and better protected from cross-domain state leaks.

You can now browse, filter, and act on social engagement data directly from the unified dashboard. This provides real-time visibility into thousands of social triggers in one place.

We have increased our browser pool capacity by 50% to better support high-volume bulk operations. This significantly reduces the frequency of exhaustion errors during peak scraping loads.

When a request times out, the API now provides machine-readable guidance on the most efficient scraping mode to use. This helps you optimize your integration for maximum reliability.

Improved screen reader support and keyboard navigation for billing and transaction records. This ensures a more inclusive and reliable experience for all developers.

When your session expires, the platform now remembers your intended destination. After re-authenticating, you will be automatically returned to your deep-linked page.

Resolved a bug that caused legitimate scraping requests to fail with a zero-balance error. Your available credits are now correctly processed and displayed across all services.

Fixed issues where search results did not reset pagination or accurately reflect filtered counts. Navigation and interaction across all dashboard tables are now more consistent.

We have patched dozens of known vulnerabilities across our core infrastructure. This update strengthens the overall security posture of our API and dashboard environments.

Admins can now modify or remove their replies on support tickets directly from the dashboard. This allows for quick corrections of typos or the redaction of sensitive information without needing manual intervention.

Media uploads and downloads, including snapshots and document generation, are now handled asynchronously. This prevents individual file operations from stalling other tasks, significantly increasing throughput for batch scraping jobs.

New distributed locking prevents multiple identical requests from triggering redundant data fetches simultaneously. This reduces backend load and ensures faster response times during traffic spikes for frequently accessed resources.

We have optimized resource allocation to support higher concurrency for parallel scraping jobs. This improvement has successfully reduced intermittent job failures by approximately 29% for heavy workloads.

The usage dashboard now correctly includes network-level failures, such as timeouts and DNS issues, when filtering by errors. You can now see a complete picture of job health, including failures that occur before a status code is assigned.

Fixed an issue where screenshot and PDF generation tasks would occasionally return errors. All generated assets are now consistently accessible across our entire processing network.

Account re-engagement and credit exhaustion notifications have been restored and updated with personalized content. You will now receive timely, branded alerts regarding your account status and usage thresholds.

Fixed a UI bug where account spending limits would appear unset immediately after being saved. The dashboard now accurately reflects your current limits and ensures they persist correctly across page reloads.

Advanced content extraction features are now fully operational across all processing nodes. This ensures consistent, high-quality data parsing regardless of which part of our network handles your request.

Hardened our infrastructure against connectivity and memory pressure during high-concurrency tasks. These changes prevent service degradation during peak scraping loads, ensuring your requests are processed without interruption.

Various minor updates have been applied to improve dashboard synchronization, billing refund reliability, and extraction fallback accuracy.

We have resolved an underlying issue that could cause intermittent service availability problems. You will now experience more stable connections and fewer request timeouts during high-traffic periods.

You can now successfully initialize environments that focus on centralized coordination without local processing. This fix ensures that specialized configurations pass all startup checks without manual intervention.

Backend updates now prevent specific connection errors that could occur during high-traffic periods or system deployments. This ensures more consistent uptime and fewer unexpected interruptions for your integrations.

We resolved a display bug where automated onboarding and inactivity emails could show a negative credit balance. Your email notifications will now accurately reflect your available account credits at all times.

Resolved an issue where special characters in system labels could result in malformed data payloads. This ensures that all automated alerts and notifications are delivered with valid, readable information.

The Python SDK now supports direct tier selection and proactive warnings for usage limits. These tools empower you to better manage your budget and optimize request costs directly from your code.

API responses now include proactive notifications when you are approaching your account's capacity limits. This allows your application to manage scraping volume dynamically and avoid hitting usage caps unexpectedly.

You can now explicitly select specific performance tiers through the SDKs to better balance request costs and success rates. Your API responses will also now include clear warnings when your scraping activity approaches plan-specific volume caps.

API responses now provide more specific naming for various bot protection challenges encountered during requests. This extra detail replaces generic labels, helping you better understand and troubleshoot why a request was blocked.

We have extended wait thresholds for resources during periods of high traffic volume. This change reduces failure rates during usage spikes, ensuring your most demanding scraping jobs complete successfully.

Plus 3 internal improvements for better reliability and performance.

We have optimized resource allocation to double the number of concurrent requests the platform can handle. Your batch jobs and large-scale scraping tasks will now complete significantly faster.

The crawler now automatically retries pages that fail due to temporary connection issues or system blocks. This ensures that outbound links are always captured, allowing your crawls to reach their full intended depth without missing pages.

Internal wait times have been standardized to prevent premature timeouts during periods of high demand. You will experience fewer connection errors and more stable performance when the system is under heavy load.

We have optimized our routing logic to ensure that domains are no longer permanently excluded from high-performance tiers after experiencing temporary failures. Domains are now periodically re-evaluated, ensuring your long-term scraping tasks maintain the highest possible success rates.

Updated logic for identifying site-specific challenges leads to more reliable scraping of protected targets. You will see fewer intermittent failures on sites with advanced automated protections.

Optimized infrastructure now provides additional headroom for resource-heavy browser sessions. This results in greater stability and consistency when your scraping tasks require significant memory.

Fixed a crash that occurred when a scraped URL returned a top-level JSON array as its primary content. The API now correctly handles these data structures, allowing for more robust data extraction across diverse websites.

Refined our billing logic to ensure absolute precision when calculating usage for zero-cost operations and edge-case scenarios. Your credit balance and history will now consistently reflect your actual API consumption.

Corrected a maintenance task issue to prevent active or scheduled jobs from being cleared prematurely. This ensures that your long-running tasks and their associated data remain accessible and secure.

Improved the accuracy of credit restorations for tasks where internal tracking data might have expired before processing. This ensures your account is always correctly credited for any incomplete or failed requests.

Fixed a bug that could cause errors for new users during their first sign-in or while viewing their account dashboard. This update ensures a smooth and reliable experience for all users managing their API keys and usage.

Resolved a crash that occurred when processing articles containing multiple metadata blocks. This ensures reliable data extraction and fewer job failures when scraping complex news and media websites.

Fixed an issue where cached scrape results could occasionally return in a different format than fresh requests. All API responses now follow a unified structure, simplifying your data parsing and integration logic.

Our automated browser solvers are now more effective at detecting and bypassing advanced JavaScript-based challenges that previously resulted in empty responses. This update significantly reduces failed requests on heavily protected sites, providing a more seamless data extraction experience.

Improved the sanitization of error messages within system reports to ensure they render correctly and securely. This prevents unexpected formatting issues or text injections caused by special characters in error details.

Scraping results are now automatically managed with a 30-day retention window to keep your workspace performant. This ensures your data environment stays clean while maintaining high speeds for recent job lookups.

Optimized resource management now prevents performance degradation during system updates. These changes ensure your scraping requests remain uninterrupted even during peak traffic and maintenance windows.

Enhanced resource handling prevents background processes from stalling and blocking your scraping queue. This improvement leads to significantly higher success rates for complex, long-running extraction tasks.

We have updated our data policies to archive older scrape results while preserving your full job metadata indefinitely. This allows you to audit your long-term scraping history without impacting platform performance.

Plus 3 internal improvements for better reliability and performance.

We have overhauled core data retrieval patterns to eliminate resource-heavy operations across our infrastructure. This results in more consistent API responsiveness and faster dashboard interactions even during global traffic peaks.

Users can now run twice as many concurrent browser-based scraping tasks without increasing their resource footprint. This allows for significantly faster data collection at scale.

The public API specification has been fully synchronized with the latest platform updates. Developers can rely on the documentation for the most current endpoints and schema definitions.

Backend data processing has been tuned to handle complex queries faster and prevent system-wide delays. This results in more consistent API response times during peak loads.

The Node.js SDK now supports additional parameters for scraping and extraction, including LLM provider selection and custom templates. This ensures developers have full access to our latest API features natively.

We updated our crawl engine to ensure more predictable and exhaustive results during deep site traversals. This change prevents pages from being skipped and ensures consistent data discovery regardless of crawl speed.

Fixed a reporting discrepancy where account totals were sometimes capped by display limits. Your dashboard now reflects the true count of your team signups and usage data across all pages.

Improved the feedback loop for failed scraping jobs to provide more accurate error states. You will no longer see confusing "Processing" indicators or incorrect data warnings for jobs that failed before producing output.

Onboarding banners and UI notifications now correctly remember your dismissal preferences across different sessions. This creates a cleaner and more efficient workspace for returning developers.

Resolved several underlying issues to prevent intermittent API client errors and improve metric calculation accuracy. These updates contribute to a more predictable and robust integration experience.

A critical update to our resource management engine prevents rare deadlocks that could occur during high-pressure scraping sessions. Your API calls will now remain stable and resolve correctly under any load condition.

Internal data processing has been hardened to better handle simultaneous updates to your analytics data. You will see improved reliability when running multiple concurrent scraping tasks that contribute to your domain insights.

We introduced a background process that automatically identifies and refunds credits for interrupted scraping tasks. This ensures your balance is correctly restored even if a session is disconnected.

Crawl exclusion patterns are now more flexible and correctly ignore specified URLs even when leading slashes are omitted. This provides more precise control over which pages are scraped.

The dashboard now gracefully handles and displays page-level errors during crawls instead of crashing. This makes it easier to debug specific failures within large scraping jobs.

We fixed an issue where long-running scraping tasks could prematurely expire and become unpollable. Your crawls will now remain manageable until they are fully completed.

We resolved an issue where automated refunds could over-calculate credits in specific crawl scenarios. Your credit balance will now more accurately reflect your actual usage and eligible refunds.

Internal optimizations resolve intermittent conflicts during high-volume data processing and ensure system alerts are delivered reliably. This provides better visibility into job status and platform performance.

We have improved the sanitization of sensitive information in automated error reports. This ensures that personal identifiers and private keys are never exposed during troubleshooting or log analysis.

You will see significantly higher success rates on regional e-commerce variants through better alignment of browser settings with target locations. This update addresses recent success rate regressions on Swedish, French, and Canadian domains.

We have improved our browser fingerprinting to resolve detection issues on high-traffic social media platforms. This ensures more consistent data extraction and lower block rates for your requests.

API error responses now provide more specific details when a request fails on a complex site. This allows for better debugging and insight into whether a failure was due to a network issue or a site-specific block.

Our resource management has been optimized to prevent content retrieval errors during periods of high concurrency. This ensures that your scraping jobs start reliably even when the platform is under heavy demand.

The platform now automatically identifies domains with unsolvable bot challenges to provide immediate feedback. By avoiding expensive extraction attempts that are destined to fail, you receive faster responses and save on processing time.

Plus 2 internal improvements for better reliability and performance.

You will now receive clear notifications if your scraping playbooks contain conflicting header definitions or overlapping configuration keys. This helps you debug complex scraping logic and ensures your requests are sent exactly as intended.

We have upgraded our core data systems to more efficiently handle high-concurrency workloads and complex queries. This optimization provides a more stable foundation for scaling your largest and most intensive scraping projects.

We have resolved an issue that prevented some users from logging into the dashboard when multiple account records existed. Access has been restored for all affected accounts, ensuring a smoother management experience.

We fixed a logic error that caused some scraping strategies to conflict with site requirements, leading to recurring failures. The system now detects and corrects these strategy contradictions automatically and handles complex site challenges more reliably.

Job logs now correctly attribute requests rejected by protective limits to the specific domain targeted. This provides more accurate data for your internal monitoring and usage analysis.

The web dashboard now experiences significantly fewer service interruptions and failures during system maintenance. This ensures you have consistent access to your scraping results and account management tools.

We have enhanced the reliability of the API's runtime processes to prevent unexpected service restarts under heavy memory load. This ensures higher availability and more consistent performance during your peak scraping operations.

Fixed an issue where certain historical records were incorrectly excluded from automated archival processes. This ensures your data retention policies are applied consistently, keeping your workspace logs accurate and performant.

Resolved a rare synchronization conflict between background maintenance tasks and active API requests that could cause sessions to hang. Your scraping jobs will now continue to process smoothly even during high-volume background cleanup windows.

We have refined our internal resource management and connection handling to provide a smoother, more consistent API experience. These updates reduce latency spikes and ensure your integrations remain stable even during periods of high traffic.

The session playback interface now isolates runtime errors to ensure they do not disrupt the rest of your dashboard session. This means you can continue to view metadata and AI analysis even if a specific replay segment encounters an issue.

We have improved our error detection logic to provide more accurate feedback when requests encounter data conflicts or integrity issues. This allows for faster debugging and more reliable handling of edge cases within your custom integration.

Our data management services have been updated to ensure that organization tags are applied accurately across all records. This prevents archived data from interfering with your active categorization and reporting workflows for better data consistency.

The Node.js SDK is now available under the simplified `alterlab` package name for easier installation. You can now use `npm i alterlab` to integrate our API into your projects with a cleaner dependency structure.

Search engine domains are now exempt from standard domain-level circuit breakers, ensuring more consistent performance for search-heavy workflows. This change improves reliability when gathering critical data from major search providers.

System optimizations have unlocked additional concurrent capacity, allowing for more simultaneous browser sessions per instance. Tasks that encounter temporary resource pressure are now automatically requeued instead of marked as failed.

Scraping attempts on domains with known unsolvable challenges now fail faster, preventing unnecessary wait times and resource lockups. This ensures your processing capacity is reserved for jobs with a higher probability of success.

Improvements to the job orchestration system ensure that cancelled requests are immediately halted across all processing stages. This prevents the consumption of credits or resources for tasks you no longer wish to continue.

We improved the system's logic for handling complex routing scenarios to prevent premature failure reports. This ensures higher success rates and more reliable data delivery for challenging extraction targets.

Concurrent data updates for domain-level analytics are now more resilient against synchronization conflicts. This ensures your reporting remains consistent and accurate even during high-volume, concurrent operations.

Plus 4 internal improvements for better reliability and performance.

We have unified our data retention policies to ensure domain performance statistics are consistently available for 90 days. This provides more reliable long-term insights into your scraping success rates.

We resolved a synchronization issue that caused deep crawls to occasionally lose track of discovered URLs or webhook data across cycles. Your multi-level crawling tasks will now consistently report results for every discovery phase.

The recording player now correctly displays duration and progress for active or recently completed scraping sessions. You can now more effectively troubleshoot and review long-running or open browser sessions.

Automated discovery modes are now fully compatible with JavaScript-heavy landing pages, ensuring consistent data extraction during initial site scans. This resolves an issue where discovery tasks would fail to initialize under certain conditions.

The monitoring interface now distinguishes between pending events and actual errors, providing a clearer view of your integration health. This ensures your dashboard metrics accurately reflect failed deliveries rather than processing activity.

This release includes several backend updates to eliminate race conditions when resuming large-scale crawls or updating domain analytics. These changes ensure your data reports and crawl states remain consistent even under heavy concurrent load.

The playground dashboard now handles structured error responses more gracefully without crashing. Error messages are now normalized into readable strings, allowing you to diagnose API issues more effectively.

Internal infrastructure routing for specific search engine endpoints has been improved to prevent unnecessary stability triggers. This results in more consistent performance when scraping search engine results pages.

We fixed a build-time issue where essential configuration properties were missing in the Node.js SDK. Streaming features and API authentication now function correctly out of the box in all environments.

Resource management for browser-based scraping sessions is now more robust, ensuring accurate usage tracking. This prevents unexpected session limits and improves stability for high-concurrency workloads.

The platform now respects manual edits or dismissals made to automated support suggestions. This prevents the system from overwriting your team's decisions when new suggestions are generated.

Scraping errors in the Playground now display human-readable messages instead of technical objects. We've also removed placeholder text that appeared on successful crawl completions for a cleaner experience.

Automated support features now handle connection interruptions more gracefully. This ensures that intermittent network issues don't result in missing or failed background analysis tasks.

We've strengthened our server-side sanitization processes to ensure all rendered content is secure. This provides an additional layer of protection for your team when viewing data through the dashboard.

The crawler now supports link discovery on modern web applications that require JavaScript execution to render content. This enables deeper data extraction from sites built with modern frameworks that do not include navigation links in their initial HTML.

The system now better handles domains with intermittent success rates, preventing unnecessary service interruptions. This ensures your scraping jobs continue to run reliably.

We have improved our ability to distinguish between different types of site protections and access limits. This provides more accurate error reporting when navigating complex page gates.

Automated configurations have been tuned for several regional media sites to ensure faster navigation and higher success rates. This reduces the retries needed to fetch content.

Wait times have been significantly reduced during high system demand by failing fast when resources are unavailable. This prevents applications from hanging during traffic spikes.

Browser environments now include more robust script execution capabilities and accurate environment signatures. This improves success when scraping sites with complex interactive scripts.

Internal resource allocation has been fine-tuned to better match real-world usage patterns. This allows for more reliable performance when running multiple concurrent scraping tasks.

Plus 3 internal improvements for better reliability and performance.

The system now automatically probes multiple common locations to find sitemaps, even when they are not explicitly declared in standard locations. This improves automated discovery for sites using various content management systems with non-standard configurations.

We resolved an issue where browser sessions could occasionally become unavailable after a crash. Your allocated scraping capacity is now more accurately tracked and available.

This update includes more accurate job status reporting and refined type definitions in our libraries. Connection handling for ingestion has also been improved to prevent hangs.

Fixed a synchronization issue that could cause browser session counters to become inaccurate over time. You can now rely on more consistent availability and management of your active browser slots.

Our extraction engine now handles pages with incomplete metadata tags more effectively. This reduces processing errors when scraping complex web structures and improves overall data reliability.

Resolved an issue where some URLs were incorrectly classified as landing pages. Your scrape results and metadata will now accurately reflect the specific page types you are targeting.

We have implemented automated system refreshes to prevent resource exhaustion during high-volume operations. This ensures that browser-based requests are processed consistently without interruption.

We resolved a navigation error that could occur when reviewing scraping history with specific authentication states. You will no longer encounter redirect loops, providing a more reliable debugging experience.

Your deep crawls will now consistently find and traverse links, even when content is retrieved from the cache. This fix ensures that discovery correctly identifies new pages from the content of every crawled URL.

We resolved an issue that caused the management console to incorrectly sign users out during certain proxy operations. This ensures you can monitor sessions without experiencing unexpected interruptions or redirects.

Fixed a bug that caused recursive page discovery to fail during multi-level crawls. The system now accurately tracks source URLs for all discovered pages, ensuring complete and uninterrupted coverage across complex website structures.

Fixed an issue where valid data sent to session endpoints was being incorrectly rejected with validation errors. API reliability is now restored, ensuring that your ingestion requests are processed successfully without unexpected failures.

Filtering session recordings by specific edge cases now works reliably within your dashboard. This fix ensures that your search criteria are correctly applied by the API, allowing for more precise management of your captured data.

Internal request handling has been updated to better validate client headers and prevent manipulation. This ensures a more secure connection between your services and our endpoints.

We have hardened our request validation process to prevent unauthorized identity spoofing. This ensures more reliable rate limiting and consistent performance for all developers.

Payload size limits are now strictly enforced across all transfer types, including chunked data streams. This update maintains platform stability by ensuring all incoming data adheres to standard size constraints.

The API now recognizes and processes additional automated challenge resolution states during the scraping process. This ensures your sessions continue uninterrupted and provide more accurate feedback when navigating complex security checkpoints.

Your requests are now much less likely to encounter temporary availability errors during periods of intense scraping activity. We have expanded our intake capacity to ensure your jobs stay in the queue and complete successfully even when target sites are slow.

Plus 2 internal improvements for better reliability and performance.

We've significantly improved success rates for Romanian news domains to ensure consistent data delivery. You can now extract content from these sources with near-perfect reliability.

API responses and SDKs now support structured error objects for more granular debugging and error handling. This allows your application to programmatically respond to different failure states more effectively.

We have resolved over 40 minor issues across our scraping infrastructure to ensure a smoother experience. These updates provide better overall performance and reliability across all supported domains.

We have expanded our resource filtering to automatically block telemetry, ad trackers, and decorative assets during navigation. This reduces your bandwidth consumption and speeds up the delivery of essential page content.

Internal optimizations to our request handling pipeline significantly reduce processing overhead and improve responsiveness. You will experience more consistent performance even during high-concurrency workloads.

The API now negotiates modern compression standards for all request types to minimize transfer sizes. This leads to faster response times and lower data usage for text-heavy scraping tasks.

Our connectivity logic is now more tolerant of transient network glitches, preventing healthy routes from being prematurely sidelined. This results in higher overall success rates for your requests.

Error messages now clearly distinguish between account balance issues and internal system errors. This allows you to manage your credits more effectively and troubleshoot integration issues faster.

You can now set a soft cap on raw response body sizes directly within the Node and Python SDKs. This allows for more efficient resource management when scraping content-heavy websites.

We have optimized internal resource allocation to support a higher number of simultaneous browser sessions. This improvement reduces the likelihood of session initialization failures during periods of peak scraping activity.

Scraping pages with complex symbols or diverse language characters is now more reliable across our entire data pipeline. This fix ensures that supplementary characters are handled correctly, preventing data loss when processing content from international sources.

We have resolved an issue where structured error data could cause unexpected validation failures in the API response. You will now receive consistent, well-formed responses even when jobs encounter complex protection blocks or page-level errors.

The system now more accurately manages job retries when they reach the limits of your current subscription plan. This change prevents redundant processing attempts and ensures you receive definitive job results more quickly without unnecessary waiting.

Error messages now explicitly notify you if a plan upgrade fails due to an insufficient account balance. This removes ambiguity and helps you resolve billing issues quickly without guessing the cause.

Our systems now more effectively re-evaluate strategies for accessing sites with sophisticated anti-bot protections. This ensures better recovery and higher success rates when website architectures change.

We resolved several issues related to connection resource management and job tracking for long-running requests. These changes ensure consistent API behavior and reliable credit accounting for every task.

We resolved an issue where browser sessions with interactions weren't always released correctly. This ensures your account limits are accurately tracked so you never lose access to available slots.

Enhanced pre-flight checks now better account for potential cost adjustments during complex scraping tasks. This prevents jobs from failing prematurely due to balance constraints once started.

We resolved an issue that caused intermittent errors when attempting to view or retrieve session recordings. Users can now consistently access their recording data for debugging and quality assurance without encountering unexpected service errors.

A default 5MB limit is now applied to response bodies to ensure optimal processing speeds. You can adjust this limit using the new `max_response_bytes` parameter or set it to zero for unlimited size.

The API now identifies permanent blockages and terminal failures earlier in the request lifecycle. This prevents unnecessary waiting for retries that are guaranteed to fail, resulting in faster final responses.

Our scraping engine now automatically bypasses domains currently experiencing outages or high failure rates. This ensures your scraping jobs conclude faster by focusing resources on reachable targets.

Plus 4 internal improvements for better reliability and performance.

Funnel and journey queries now resolve significantly faster, allowing you to visualize user paths without delay. We have optimized our data indexing to handle large-scale session history more efficiently.

Analysis of user funnels is now more stable when processing extensive historical data. This prevents performance degradation and ensures consistent response times for your journey reports.

The session management interface now loads data more efficiently by eliminating redundant network requests. This results in a smoother, more responsive experience when reviewing recordings.

Administrative permissions now refresh automatically during active sessions to ensure you have uninterrupted access to management tools. This prevents potential lockouts and ensures your account status remains accurate without requiring a re-login.

We resolved an issue where active user sessions were being incorrectly revoked before their intended expiration. This fix ensures your API authentication remains valid and your workflows continue without unexpected interruptions.

Attempting to scrape our own domain via the demo endpoint now returns a specific, helpful instruction. You will no longer see generic security errors when testing the platform's capabilities.

Fixed an issue that caused redundant request storms when the dashboard encountered temporary service interruptions. Navigating alert recordings is now significantly smoother and more reliable.

Resolved a data mismatch that could occasionally prevent job history from being updated correctly. Your scraping logs and terminal state transitions are now recorded with complete accuracy.

User recordings are now correctly linked to authenticated accounts from the very start of a session. This ensures that logged-in activity is never mislabeled as anonymous due to initialization delays.

We have optimized how session data is transmitted to prevent loss when a user closes their browser tab. Large data buffers are now intelligently processed to ensure every event is captured reliably even during abrupt exits.

We have adjusted our data aggregation schedules to ensure that weekly reports include all relevant activity. This eliminates potential gaps in insights that could previously occur during weekend maintenance windows.

Automated optimizations now strictly respect your configured minimum quality requirements for all requests. This guarantees that your tasks always run with the specific resource levels and rules you define.

We have implemented stricter validation and parameter filtering for recording management endpoints. These updates enhance the security and predictability of all administrative data requests.

You can now utilize AI to analyze recorded sessions for deeper behavioral insights. This enables automated detection of edge cases and user experience patterns directly from your scrape results.

Our technology detection capabilities have grown to support over 80 distinct categories, including UI libraries and payment providers. This provides much richer metadata about the tech stacks powering the sites you scrape.

New parameters in our Search API and SDKs allow you to control content filtering levels directly. You can now toggle search safety settings within your requests to ensure more relevant results for your specific use case.

We have completed an exhaustive audit and optimization of our internal routing and execution pipelines. This results in more stable connections and improved success rates across a wider variety of complex domains.

Browser emulation now features deterministic fingerprinting and more realistic hardware signals, such as synchronized battery status and network connectivity consistency. These improvements make automated requests significantly harder to distinguish from genuine human traffic.

We refined our technology fingerprinting to eliminate false positives on popular CSS frameworks and design systems. This ensures that the metadata returned by our detection tools is more accurate and actionable.

The engine now detects rejection signals much faster during automated challenges, reducing the time spent waiting on blocked requests. This improves your overall throughput by freeing up execution resources more quickly.

Plus 22 internal improvements for better reliability and performance.

Fixed an issue where specific data payloads from modern frontend frameworks were being missed during extraction. You will now see more complete and accurate data capture from sites built with the latest reactive libraries.

Resolved a bug where certain advanced scraping parameters were being dropped during request construction. All specified configurations, including custom budget and cache settings, are now correctly passed through to the execution engine.

Improved the reliability of ticket management, including better handling of re-opened issues and assignment tracking. This ensures a more consistent experience when interacting with our integrated support platform.

Fixed a calculation error that inflated block counts for sites using specific client-side rendering techniques. Your success metrics now more accurately reflect the true state of your scraping jobs for single-page applications.

Improvements to data anonymization ensure that user-identifying information is fully cleared during deletion requests. This provides stronger privacy guarantees and simplifies compliance for developers managing sensitive data.

We’ve implemented stricter credential requirements for management and configuration endpoints. This adds an extra layer of defense-in-depth to protect your account's administrative operations and data funnels.

Standardized error responses across management interfaces prevent potential account enumeration attempts. This protects your team's privacy by ensuring that sensitive account states are not leaked through API feedback.

The documentation portal is now automatically synchronized with the live API specification. This ensures that every endpoint, parameter, and response object you see in the guides is always up-to-date with the latest production changes.

The Python and Node.js SDKs now support advanced parameters for system proxy usage, specific proxy country selection, and automatic cookie banner removal. These additions give you more granular control over how your requests are routed and how pages are rendered before data extraction.

Submitting a support request or contact form is now significantly faster. By moving notification processes to the background, we have eliminated the wait time for email delivery during the submission process, allowing for immediate confirmation of your request.

Our Discord support tools have been updated to provide more reliable ticket creation for all community members. This ensures a smoother transition from community chat to official support channels without encountering data validation hurdles.

Plus 8 internal improvements for better reliability and performance.

We have resolved several issues in the support dashboard, including accurate activity timelines for closed tickets, restored attachment access for anonymous requests, and a fully functional GDPR deletion endpoint. Ticket status logic has also been refined to ensure active conversations are never pre

Replies to closed or resolved tickets via email now automatically re-open the original conversation for better continuity. Additionally, emails sent to archived threads will now correctly trigger the creation of a new ticket, ensuring that no communication with our support team is lost.

The dashboard now handles network interruptions more gracefully with improved error states in the support list. We have also updated the interface to ensure that feedback widgets only appear on relevant, completed tickets to avoid confusion.

This update hardens our data handling by preventing the exposure of sensitive account metadata in support responses and protecting against common injection vulnerabilities in statistics and exports. We have also implemented server-side validation to ensure ticket source and priority metadata cannot

You can now manage technical inquiries, search the knowledge base, and submit feedback directly from the dashboard. This unified system includes ticket tracking, secure file attachments, and real-time notifications for faster issue resolution.

Our new Smart Deposits system provides intelligent recommendations for credit top-ups based on your usage patterns and tier benefits. We have also added detailed tooltips and quick-deposit options to streamline account management.

All REST API documentation is now automatically synchronized with our core engine to ensure 100% accuracy for every endpoint. This eliminates discrepancies between the docs and live responses, providing you with reliable integration guides.

We have increased the efficiency of our job processing queues to better handle sudden spikes in scraping volume. This prevents false rejection errors during peak periods and ensures smoother performance for large-scale operations.

Both Python and Node.js SDKs have been updated with new type definitions for billing and tier escalation details. Developers can now benefit from improved autocomplete and compile-time validation when building complex integrations.

We resolved an issue where real-time status updates could be lost for certain ticket types or during specific polling intervals. Notifications are now delivered reliably across all dashboard sessions, ensuring you never miss a reply.

Several edge cases in the credit refund system were addressed to ensure that cancelled tasks always return credits to your balance correctly. This includes improved handling of multi-step cancellations and data synchronization.

This release includes various stability updates, such as improved attachment upload reliability, smoother dashboard navigation, and more accurate satisfaction survey submissions. We also fixed a race condition that occurred when rapidly reopening feedback forms.

We implemented advanced protection against sandbox escape techniques and unauthorized script execution. This update blocks sophisticated methods of bypassing script isolation, ensuring your scraping tasks remain secure and private.

All CSV exports now include automatic sanitization to protect against formula injection and other spreadsheet-based vulnerabilities. Your data remains safe even when processed in external tools like Excel or Google Sheets.

We have strengthened our data access controls, including sender verification for ticket replies and strict path isolation for file attachments. These updates prevent unauthorized access to support data and ensure the privacy of your communications.

A new background recovery mechanism ensures that credits from cancelled requests are always returned to your balance. The system now automatically detects and resolves pending refunds that were previously interrupted by network timeouts or concurrent locks.

The Python and Node.js SDKs now support top-level custom headers for all scraping requests. This allows for easier integration with existing systems that require specific metadata or session identifiers to be passed through to the target.

The dashboard now features unique animations tailored to specific product actions like scraping, crawling, and searching. These visual cues provide immediate clarity on the current state of your operations at a glance.

We have upgraded our browser engine to provide more realistic network fingerprints during high-concurrency operations. This improvement significantly increases success rates when accessing sites with sophisticated traffic analysis.

Geo-targeting configurations now allow for language-only requests without requiring a specific country code. This provides greater flexibility for users scraping multi-lingual platforms that serve content based on browser language preferences.

The script execution engine has been updated to reduce false positives when using standard DOM properties. This change allows for more complex browser-side logic while maintaining rigorous isolation from sensitive platform APIs.

Input limits for custom scripts are now calculated based on character count rather than byte size. This provides a more intuitive experience and more predictable limits for users working with multi-byte Unicode characters.

Plus 6 internal improvements for better reliability and performance.

The API and SDKs now correctly report a pending status when a cancellation is being processed but the refund is still in flight. This ensures that client-side logic can accurately track the state of an operation before it reaches a terminal state.

Resolved an issue where polling for non-existent or unauthorized job IDs could result in a system error. The API now consistently returns a standard not-found response, leading to cleaner integration logs and more predictable error handling.

Billing metadata now accurately reflects the state of applied refunds during the cancellation window. This fix eliminates misleading signals in your usage history and ensures transparent accounting for every credit spent.

Validation errors for browser-side actions now correctly identify the specific field causing the issue. This improvement speeds up the debugging process when configuring complex scraping playbooks.

We have implemented additional protections to prevent advanced script bypasses, including coverage for tagged template literals and sophisticated property access patterns. These updates ensure your scraping environment remains secure and isolated from the underlying platform.

Header validation has been expanded to support a wider range of special characters while strictly blocking dangerous or reserved protocol headers. This prevents malformed request data from impacting the reliability of your outbound connections.

The new automatic rendering mode intelligently detects when a website requires JavaScript, optimizing your performance and cost. You no longer need to manually toggle rendering for every request, as the API now makes the most efficient choice for you.

You can now specify both country and language for your requests to access localized content with high precision. This ensures your scrapers see the exact data presented to users in specific regions, which is critical for accurate market research.

Our SDKs now support sophisticated browser interactions, including iframe handling, shadow DOM flattening, and custom action sequences. These tools allow you to extract data from modern, complex web applications that were previously difficult to navigate programmatically.

You can now programmatically control response caching and set custom Time-To-Live (TTL) values for your requests. This allows you to balance data freshness with speed and cost, ensuring you only fetch new data when your application requires it.

We have updated our browser stack to better mimic real-world user signatures and bypass sophisticated detection mechanisms. This significantly reduces block rates and ensures more consistent data extraction from highly protected domains.

Internal resource handling has been improved to prevent API timeouts and service degradation during high-concurrency periods. This change ensures that the API remains responsive and reliable even under heavy load.

Synchronous requests using webhooks now correctly poll for results rather than just returning a job identifier. This streamlines your integration by allowing you to receive data immediately while still benefiting from background notifications.

We have resolved several edge cases where credit refunds for cancelled jobs could be delayed or lost. You can now trust that your account balance accurately reflects the status of your scraping tasks in real-time.

The Python and Node.js SDKs now perform more rigorous checks on request parameters, catching configuration errors before they reach the API. This reduces wasted requests and provides clearer error messages for faster debugging.

We have optimized our URL validation process to provide faster error reporting for restricted or invalid targets. This prevents unnecessary retries and reduces latency for requests that would otherwise fail due to safety constraints.

Latency metrics now exclude internal wait times, providing you with a more accurate measurement of actual scrape performance. This data helps you better optimize your scraping workflows and assess site responsiveness more effectively.

We have implemented a strict blocklist for restricted headers to prevent unauthorized access or protocol manipulation. This protects your scraping sessions from being intercepted or misdirected by malicious configurations.

Internal browser configurations have been hardened to ensure that security-critical isolation flags are always active. This prevents potential environment escapes and ensures your scraping sessions remain secure and private.

Administrators can now generate blog drafts through an interactive chat interface directly in the admin panel. The system provides real-time topic suggestions and draft generation with visual loading states during processing.

The new publishing endpoints enable seamless transition from draft to published content with conversation history preservation. Each session maintains context for up to 24 hours, allowing for iterative refinement of posts.

Plus 17 internal improvements for better reliability and performance.

Admin panel usage statistics now display accurate credit usage data by using the correct column names in database queries.

Customer activity displays properly in the CRM pipeline by using the correct session tracking data instead of referencing non-existent columns.

Success rate percentages now display correctly in the admin panel by computing the proper percentage values instead of decimal fractions.

Billing settings and recharge information now show accurate data by querying the correct database columns for payment configurations.

Session integration success rates now calculate properly by computing the metric in SQL rather than attempting to select non-existent database columns.

A new admin page allows you to create, edit, and manage platform announcements that appear to users. The interface provides a centralized location for controlling what messages users see when they access the platform.

The announcement management tool is now accessible through a dedicated sidebar navigation item, making it easy to find and use the announcement features without searching through menus.

Monitor your AI workforce trust levels and performance with a new dashboard showing real-time trust gauges, task-specific performance metrics, and review queue management. You can now track autonomous system behavior and approve/reject AI-generated content through an intuitive Kanban interface.

Take full control of your Herald scheduling with a comprehensive monitoring dashboard featuring job status grids, success rate gauges, and manual trigger capabilities. You can view 7-day performance history, identify jobs with high failure rates, and run jobs on-demand from a single interface.

Manage your Reddit operations with dedicated overview pages showing KPI metrics, opportunity pipelines, post performance leaderboards, and subreddit fitness heatmaps. You can now track engagement metrics, monitor opportunity progress, and analyze subreddit performance from centralized dashboards.

Organize and manage your Herald user segments with new overview and detail pages. You can view member counts, average relationship scores, and last entry times for each segment, with detailed analytics for individual segments to optimize your targeting strategies.

Plan and manage your content workflow with a new calendar view offering monthly and weekly perspectives. The Kanban-style queue interface lets you approve or reject content in bulk with reason tracking, while inline previews help you make informed decisions about scheduled content.

Track your blog syndication performance across multiple platforms with a comprehensive dashboard showing platform health, cross-platform status matrices, and aggregate syndication counts. You can monitor publishing progress, identify failed syndications, and view detailed status for each published p

The system now tracks wasted time across scraping attempts and trips circuit breakers earlier when domains consistently fail. This prevents wasting resources on domains that are temporarily unreachable or blocking requests.

Per-domain concurrency limits prevent overwhelming domains with too many simultaneous requests. This results in more stable scraping sessions and reduces the likelihood of triggering anti-bot protections.

Error fallback pages now use shorter cache headers to prevent stale error states. The system also clears trip counts properly after manual resets, ensuring domains return to normal operation faster.

Mobile users now see properly sized footers that don't clip content, and the homepage announcement bar can be dismissed. These improvements create a smoother browsing experience on smaller screens.

Worker memory limits have been optimized to prevent out-of-memory crashes while maintaining performance. This results in more stable long-running scraping operations and better resource utilization.

Plus 22 internal improvements for better reliability and performance.

Experience more reliable admin panel interactions with improved error boundaries and toast notifications for API failures. Rate limit errors, authentication issues, and other API problems now provide clear user feedback instead of silent failures, making troubleshooting much easier.

Various stability improvements including proper cleanup of video event listeners, correct breadcrumb navigation, and fixed Open Graph image sanitization. These fixes address edge cases that could cause minor disruptions.

Critical stability improvements ensure admin panel features work reliably across all pages. Authentication mismatches, broken endpoints, and data display issues have been resolved, providing a consistent experience when managing your platform operations and user data.

Logo images have been optimized for faster loading, reducing file sizes from 290KB to 78KB while maintaining quality. This results in quicker page loads and better performance across all marketing and documentation pages.

The footer video now loads only when you scroll near it, preventing the 2.2MB video from buffering on initial page load. This significantly improves above-the-fold performance and reduces data usage for users who don't scroll to the bottom.

Marketing site navigation has been standardized across all pages using a shared navigation constant. This ensures consistent menu items and improves the overall user experience when navigating between pricing, documentation, and other sections.

The homepage now features a WebGL scroll-driven tunnel intro that creates an engaging visual experience as you scroll. This modern animation enhances the first impression while maintaining fast load times through optimized rendering.

Authentication-related pages now properly exclude the sticky footer video, providing cleaner layouts for password resets, email verification, and welcome pages. This ensures these transactional pages remain focused and distraction-free.

Logo sizes and spacing have been standardized across all headers and navigation elements. This creates a cohesive visual identity throughout the platform, with proper proportions between logos and wordmarks on every page.

Various minor issues have been resolved including backup retention validation, duplicate footer prevention on documentation pages, and improved scroll behavior for short marketing pages. These refinements enhance overall platform stability and usability.

Disposable email domains are now blocked at signup initiation using an expanded community-maintained list of 5,383 domains. This prevents abuse from temporary email services and improves platform security for all users.

The system now automatically detects when a domain is experiencing repeated failures and temporarily pauses requests to prevent batch job failures. This helps maintain overall scraping stability when encountering problematic domains.

Dashboard now shows your current tier with smooth count-up animations and branded icons that scale in when you scroll. The visual progression makes it easier to see your usage limits and available capacity at a glance.

A new brand resources page provides easy access to logo downloads, color palettes with hex and oklch values, typography specifications, and usage guidelines for partners and developers.

Comprehensive integration guides for Supabase are now available, including Edge Function and pg_cron examples, SDK walkthroughs for Python and Node.js, and common use cases like price monitoring and lead enrichment.

The billing interface now displays your current tier with the new branded tier badges and includes a progression hint showing your path to higher limits. This gives you clearer visibility into your usage and upgrade options.

High Volume tier users now see a clear upgrade path to Enterprise with custom limits tailored to their workload. The dashboard celebrates your tier upgrade with a special announcement when you have available balance.

All tier displays across the platform now use the same branded tier badge system with consistent colors and icons. This creates a unified experience whether you're viewing your dashboard, billing page, or tier progression.

Plus 51 internal improvements for better reliability and performance.

Password reset emails now include your display name when available, making communications feel more personal and professional. If no name is set, the email defaults to a friendly greeting.

Usage alert emails now show accurate dollar amounts instead of inflated values. The billing system correctly converts microcent balances to dollars, preventing confusion about remaining credits.

Display credits as dollar amounts in invoice upcoming ema....

Added dedicated startup scripts and entry points for automated processes, making it easier to deploy and manage scraping operations at scale. These improvements streamline the initialization of background services.

Implemented new configuration retrieval capabilities that allow seamless integration between different components. Users can now easily access and manage configuration settings across the platform.

Replaced the previous per-process rate limiting with a centralized system that ensures consistent limits across all instances. This prevents unexpected behavior during deployments and maintains fair usage policies.

Fixed the extension update mechanism to properly handle self-hosted installations. The update system now works consistently regardless of deployment environment, ensuring users always have the latest features.

Improved the connection detection logic to correctly identify when users are properly configured. This prevents false positives in the connection status and ensures the setup process works as expected.

Resolved font loading issues that affected visual elements in the platform. All necessary resources are now properly included in the deployment, ensuring consistent appearance across all features.

Enhanced the security of alert systems by properly sanitizing input data. This prevents potential security issues while maintaining the functionality of critical notification features.

Fixed configuration validation to use consistent constants throughout the system. This ensures that all components respect the same limits and prevents configuration drift between different parts of the platform.

API discovery now correctly bills for proxy usage when required, ensuring you're only charged for the resources actually consumed during the discovery process.

The system now correctly identifies captcha challenges even when JavaScript contains comparison operators, preventing false negatives in automated detection.

API discovery no longer attempts to use Next.js development-only paths, ensuring consistent behavior across all environments and preventing failed discovery attempts.

Webhook failures from DNS rebinding attacks now properly increment failure counts, triggering automatic disabling when thresholds are exceeded to protect your system.

The batch scraping interface now accurately reflects the 100 URL limit per batch call, preventing confusion and ensuring you can plan your scraping operations correctly.

Account deletion now properly revokes all session tokens before bulk deletion, ensuring complete account cleanup and preventing unauthorized access after deletion.

The system now correctly identifies rate-limited responses with short HTML bodies, ensuring appropriate escalation and preventing misclassification of blocked requests.

Deposits exceeding the maximum limit now trigger automatic refunds and block credit grants, preventing accidental overcharges and maintaining billing integrity.

Expired sessions are now correctly identified and filtered in the admin interface, providing accurate session management and preventing confusion about active sessions.

Webhook URLs are now validated immediately before delivery, preventing DNS rebinding attacks that could occur between creation and delivery time.

Stripe webhook events that arrive before database commits now trigger proper error responses, ensuring reliable credit granting and preventing data inconsistencies.

Various internal stability enhancements and performance optimizations have been implemented to provide a more reliable scraping experience.

Plus 17 internal improvements for better reliability and performance.

Geographic proxy targeting now supports over 30 additional country code top-level domains, providing better coverage for international scraping needs. This enables more precise location targeting for your proxy requests across a wider range of countries.

Legacy API keys with empty prefixes now show a meaningful 'sk_live_' prefix instead of appearing as 16 bullet dots. This makes it easier to identify and manage older credentials in the dashboard.

The API filter on the usage page now includes SDK and ecosystem sources like python-sdk, node-sdk, mcp-server, n8n-node, and browser-ext. This provides a complete view of all non-playground usage patterns in your account.

Amazon product pages with multiple sellers now extract price data directly from variant olp slot information, inline text, and script offer data. This includes new seller counts, lowest prices, and used item counts without requiring additional API calls.

The dashboard credentials panel now correctly displays the actual key prefix from the API response instead of constructing it from UUIDs. This ensures accurate representation of your API keys in the interface.

Backup processes now correctly handle nested command patterns in error messages, preventing incomplete or malformed alert notifications. This ensures you receive accurate and complete failure notifications when backup operations encounter issues.

Webhook retry mechanisms now properly manage loading states during recursive operations, preventing UI inconsistencies and ensuring reliable delivery of webhook notifications. This provides more predictable behavior when handling failed webhook deliveries.

Text extraction from web pages now includes additional safeguards against missing attributes, preventing errors when parsing complex HTML structures. This results in more reliable content extraction for your scraping operations.

API source filtering in the dashboard now correctly excludes crawl and batch jobs, providing more accurate job categorization and filtering options. This helps you better organize and view your scraping jobs by source type.

Image blocking settings now properly apply to additional domains including booking.com and instagram.com, giving you more control over bandwidth usage and page rendering for these specific use cases.

Legacy API keys now display with appropriate prefixes, preventing confusion about key types and ensuring you can easily identify your credentials. This improves the user experience when managing multiple API keys.

Backup operations to R2 storage now include performance optimizations and proper bucket handling, preventing upload failures due to permission issues. This ensures more reliable and efficient backup operations to your R2 storage.

Backup operations now include a hard storage limit to prevent unexpected billing overages on R2 storage. This provides better cost control while maintaining reliable backup functionality.

Browser pool configuration now supports legacy environment variable names, ensuring compatibility with existing setups while transitioning to new configuration standards. This prevents disruptions when updating your environment configuration.

Credentials are now handled more securely during backup operations by using environment variables instead of writing plaintext credentials to disk. This eliminates potential security vulnerabilities while maintaining the same functionality for your backup workflows.

Added domain-based proxy bandwidth blocking for ads and trackers, including 65 new domains like analytics services, ad CDNs, and consent managers, reducing unnecessary data transfer and improving scraping efficiency.

Fixed domain blocking logic to properly handle URLs with user credentials and URL fragments, ensuring blocked domains like ad networks and trackers are correctly identified and filtered regardless of URL format.

Raised auto-recharge runtime cap from $1,000 to $2,000 and deposit cap to $2,000 to match frontend pack offerings, eliminating validation errors for users setting higher billing thresholds.

Increased cache TTL to 60 minutes and optimized browser configuration loading, reducing redundant network calls and improving overall API response times for repeated requests.

Launched a redesigned /best-web-scraping-api landing page featuring a 45° ASCII benchmark table, canvas ASCII background, and visual ranked cards with animated progress indicators for better user engagement.

Introduced a new 3D rolling cubes animation component using pure CSS 3D transforms and requestAnimationFrame, replacing the previous CardStream component in the BenchmarkHero section for a more dynamic visual experience.

Plus 6 internal improvements for better reliability and performance.

The system now automatically retries fetchBatch and fetchWebhookLog operations when encountering stale API keys, transparently handling key rotation without requiring manual intervention from users.

Fixed key prefix display in CredentialsPanel and improved LiveTerminal functionality by properly fetching decrypted key values, ensuring users can accurately manage and use their API credentials.

Enhanced scrape route security by prioritizing Cloudflare's cf-connecting-ip header over client-supplied x-forwarded-for, making it harder for malicious actors to spoof their origin in proxy requests.

Plus 29 internal improvements for better reliability and performance.

Batch proxy routes now accept X-Key-Id as an alternative to X-API-Key, allowing the server to resolve plaintext keys on demand instead of relying on sessionStorage caching.

Added on-demand API key decryption for batch operations, preventing fallback to truncated UUIDs when keys aren't cached in sessionStorage.

Corrected batch form submission to use 'urls' field instead of 'requests', ensuring proper API request formatting for all dashboard batch submissions.

Worker job queue processing is now more responsive with a 10-second timeout limit, preventing indefinite blocking and ensuring tasks complete in a timely manner. This improvement reduces delays in your scraping workflows and improves overall system throughput.

The system now actively monitors idle database connections, alerting you when connection counts exceed safe thresholds. This proactive monitoring helps prevent performance degradation and ensures your scraping operations maintain optimal database performance.

Critical system components now handle missing environment configurations gracefully, preventing unexpected failures during deployment or configuration changes. This improvement ensures your scraping infrastructure remains operational even when certain optional services are temporarily unavailable.

System health checks now provide more accurate status reporting by properly handling missing service configurations. This improvement gives you clearer visibility into system health and helps you quickly identify and resolve infrastructure issues.

The system now uses memory more efficiently during high-load scenarios, preventing performance degradation during intensive scraping operations. This optimization ensures consistent performance even when processing large volumes of data or handling multiple concurrent requests.

Various minor issues have been resolved to improve overall system reliability and performance. These fixes address edge cases and improve the robustness of core scraping functionality.

Image processing now correctly handles various file formats and color modes during uploads. Problematic image modes are automatically converted before saving, preventing cryptic errors and ensuring consistent behavior across JPEG, PNG, and WEBP uploads.

Browser pool operations now properly synchronize access to shared resources, preventing potential conflicts when multiple processes interact with browser instances. This ensures more stable and predictable behavior during concurrent scraping operations.

Admin credit adjustments now use advisory locks to prevent race conditions during balance updates. This ensures accurate credit tracking and prevents potential inconsistencies when multiple administrators modify account balances simultaneously.

Rate limiting for admin operations now properly handles Redis connection failures by failing closed rather than allowing unlimited access. This maintains security boundaries even during infrastructure issues.

Audit log failures during privilege changes now generate proper error notifications instead of silent warnings. This ensures critical security events are properly tracked and administrators are alerted to potential issues.

Soft-deleted and fraud-flagged admin accounts are now properly blocked from accessing sensitive features including blog management, proxy services, and API endpoints. This closes potential security gaps where disabled accounts could still perform privileged actions.

A comprehensive job history page is now available at /dashboard/history, allowing users to browse all past jobs from PostgreSQL with advanced search, filtering by URL/status/mode, pagination, and response viewing capabilities. The sidebar navigation has been updated to include this new History entry

Internal refinements to the dashboard layout and component structure for improved consistency and maintainability.

Job status counting operations now use batch Redis MGET commands instead of sequential GET calls, reducing Redis round-trips from O(n) to O(1) per reconciliation. This optimization cuts total GET operations for a crawl from O(n²) to O(n), significantly improving performance for large-scale scraping

Rate limit checks now occur before expensive network operations during URL discovery, preventing over-limit API keys from triggering unnecessary sitemap or start-page requests. This change reduces wasted resources and ensures users receive immediate 429 responses when they exceed their rate limits.

API key scope fallbacks now include billing permissions by default, ensuring consistent access control across all API key operations. This change improves security and prevents unexpected permission issues when working with billing-related API endpoints.

Plus 5 internal improvements for better reliability and performance.

Low balance alerts and auto-recharge triggers are now properly wired into both inline/sync and async queued billing paths. The system now correctly handles balance checks and sends timely notifications when account balances run low, preventing unexpected service interruptions during active scraping

Spending by Type charts now show accurate costs instead of estimated values based on request counts. The Recent Activity section maintains consistent height even when empty, and fallback messages display correctly when per-type spend data is unavailable, providing users with reliable billing informa

The system now properly handles structured error metadata from workers, accepting dictionary error formats in CrawlPageResult instead of raising validation errors. This enhancement provides more detailed error information for debugging and improves the reliability of error reporting in the dashboard

Deposit pack cards have been consolidated into a unified flat-row layout, removing the previous split between Regular and Smart deposit sections. This streamlined design provides a cleaner, more consistent user experience when managing account deposits and viewing available payment options.

Amazon Australia timeout settings have been aligned with other Amazon locales, using consistent max_wait_ms and nav_timeout_ms values across all regional endpoints. This standardization ensures reliable scraping performance and prevents timeout-related issues when working with Australian Amazon site

Set a balance threshold and AlterLab automatically tops up your account when you dip below it. Choose your trigger amount, top-up pack, and preferred payment method — it just works in the background. Configure it from the new billing page.

Deposit packs now come with graduated volume bonuses — the more you deposit, the more free credits you receive. Tier badges show your current tier and exactly how much extra you unlock at each level.

The billing page has been rebuilt as a single-page layout with a new tier rail, combined transaction and events history, receipt tracking, and a live RecentActivity feed — all without needing to switch tabs.

Get an email notification before your balance hits zero. Alerts fire at configurable thresholds so you can top up before any scraping jobs are affected.

The platform now automatically promotes your oldest payment method as default when no default is set, and keeps auto-recharge synced when you change or remove payment methods.

All API keys now include the billing scope by default. Existing keys have been backfilled. This unlocks balance and auto-recharge endpoints for programmatic billing management.

Auto-recharge enable, disable, and delete actions are now recorded in the billing audit log. Recharge attempts track the full lifecycle — pending, success, decline, and idempotent skips.

Volume bonus credits granted at deposit time now appear as a separate line in your transaction history and on the deposit success page, so you can always see exactly what you received.

Plus 30+ additional fixes across billing, accessibility, rate limiting, and dashboard reliability.

Scraping timeouts for amazon.com.au were lower than other Amazon locale configs, causing more frequent failures on large product pages. Now aligned with amazon.com, .co.uk, and .de.

Fixed a suite of edge cases: atomic single-UPDATE for backoff state, NULL sentinel for pending recharge rows, partial unique index on payment intent IDs to prevent duplicate audit rows, and proper asyncio.to_thread wrapping for Stripe calls.

The Penetrator anti-bot tier's learned cookie storage now filters out authentication and session cookies. This prevents accidental credential leakage across domains in multi-tenant environments.

Reduced step 1 to step 2 drop-off by preventing accidental exits through disabled click-outside and Escape key dismissal. Moved the skip button to the bottom with de-emphasized text and added value proposition subtext to guide users through the process.

Plus 27 internal improvements for better reliability and performance.

Dashboard polling interval reduced from 5 seconds to 15 seconds and now pauses when browser tabs are hidden. This reduces unnecessary network requests while maintaining real-time updates when actively viewing the dashboard.

Fixed soft 404 error flagged by Google Search Console on the blog index page. The issue was caused by empty heading states when no posts were found, which has been corrected to properly display blog content.

Credit history now displays amounts in dollars instead of raw microcents, making transaction values easier to understand. Grant-type transactions are also included in credit history, and pagination has been added to recent activity for better navigation.

Broadcast promo notifications no longer expose promo codes in notification bodies, preventing unintended code sharing. User-targeted promos still include codes only visible to the intended recipient, with expiration times properly synchronized.

All audit action values now have corresponding labels and icons defined, ensuring consistent display throughout the platform. This resolves missing visual indicators in audit logs and activity tracking.

Implemented edge-level protection that blocks unauthorized POST requests to demo endpoints and rate limits demo traffic to 5 requests per 10 seconds per IP. This eliminates millions of bot requests daily that previously overwhelmed system resources.

Your account's login history now shows the city and country for each sign-in, letting you spot unfamiliar access at a glance. Location data is geo-resolved from the login IP and appears in the Login History tab under Settings.

Enhanced automated handling of interactive challenges including modern verification systems. The platform now automatically processes complex verification steps and caches authentication tokens for improved success rates.

Revised endpoint documentation to accurately reflect current scraping tier capabilities. Users now have clear guidance on demo limitations and upgraded features available in production tiers.

Plus 7 internal improvements for better reliability and performance.

Added global rate limiting to prevent distributed abuse of demo endpoints. The system now tracks total demo requests across all IPs, ensuring fair access while maintaining protection against coordinated scraping attempts.

A new automated system now evaluates pending review items against brand guidelines using advanced analysis. This ensures consistent quality standards across all submissions while providing clear reasoning for approval or rejection decisions, streamlining the review workflow.

Extraction accuracy for sofiaman.ro has been significantly improved with theme-specific selectors that match the actual DOM structure. The updated selectors replace generic targeting with precise element identification, resulting in more reliable data capture from Shopify-powered stores.

The demo environment now uses the same components as the main dashboard, providing a consistent experience across all interfaces. This unification eliminates discrepancies between demo and production environments, making it easier to test and validate scraping workflows.

Plus 8 internal improvements for better reliability and performance.

New admin dashboard provides detailed ROI tracking with per-channel metrics including ROI percentage, cost-per-acquisition, and signups per hour. View comprehensive activity ledgers with create, edit, and delete capabilities through an intuitive modal interface.

Capture and analyze attribution data from UTM parameters, referrers, and landing pages on first visit. Track user acquisition sources through enhanced signup flows and OAuth integration, with data stored in first-party cookies and session storage.

Python and Node SDKs now automatically include ecosystem identification headers in API requests. Track usage patterns across different integration methods including Python SDK, Node SDK, MCP server, n8n node, and browser extensions.

Access comprehensive analytics through new admin endpoints covering channels, cohorts, funnels, and ecosystem attribution. Query materialized views for channel performance, cohort retention, and funnel conversion metrics with real-time data refresh capabilities.

Receive automated weekly insights reports aggregating key metrics from channel performance, cohort retention, funnel conversion, and ecosystem attribution. Personalized reports delivered through the existing notification system with frequency controls.

New admin dashboard provides detailed ROI calculations, cost-per-acquisition metrics, and activity ledger with full CRUD operations. Track total costs, revenue, signups, and effort across all channels with date range filtering.

Comprehensive admin analytics API with endpoints for channels, cohorts, funnels, ecosystem attribution, and overview summaries. Includes materialized view support for fast query performance and view refresh capabilities.

SDKs now automatically send ecosystem source headers identifying integration tools like Python SDK, Node SDK, MCP server, and n8n. Attribution data is captured during signup and OAuth flows for better understanding of user acquisition channels.

Automated weekly task that queries all Pathfinder analytics views and delivers structured insights reports via Herald. Get regular updates on channel performance, cohort retention, funnel conversion, and ecosystem attribution without manual queries.

New event service provides robust behavioral tracking with Redis batching and background flush operations. Capture key user actions including signups, credit topups, subscription cancellations, and API key creations without blocking primary operations.

Modal dialogs now feature proper accessibility support including role attributes, focus management, and keyboard navigation. Enhanced user experience for cost management and activity tracking interfaces.

Plus 27 internal improvements for better reliability and performance.

Enhanced content scoping now properly handles image-heavy pages and domain-specific CSS selectors. Fixes issues with Readability stripping CSS classes and ensures promotional pages with images are correctly identified as valuable content.

The SDK now validates section filter parameters before API requests, catching typos and type errors in min_content_blocks, exclude_content_types, and content_only options. This prevents failed requests due to configuration mistakes and provides immediate feedback during development.

Plus 3 internal improvements for better reliability and performance.

Carousel detection on Shopify sites now uses a more reliable two-pass strategy. The system first looks for data-section-type attributes, which Shopify themes use to annotate major sections like slideshows, providing higher confidence in identifying the primary carousel.

Hero image classification now correctly identifies only the primary carousel container instead of tagging every image in all carousels. This prevents excessive hero tags on pages with multiple carousels and improves image categorization accuracy.

Text extraction now automatically removes navigation, header, footer, and aside elements after Readability processing. This eliminates residual boilerplate content that previously appeared in extracted text, delivering cleaner article content and more accurate text analysis.

The playground interface now properly resets after API failures, preventing the Run button from getting stuck in a disabled state. The system tracks consecutive poll failures and automatically bails after 3 attempts, ensuring the interface remains responsive for subsequent operations.

The playground now handles cases where keys created in prior sessions or seeded keys don't have cached plaintext, preventing silent failures during crawl operations.

The Run button in the playground no longer remains disabled after consecutive API failures, as the system now properly tracks and resets polling states after multiple errors.

Login and signup patterns no longer strip legitimate standalone content from paywalled sites, preserving important text that was previously removed during extraction.

The scroll_count parameter is now only included when scroll_to_load is enabled, reducing unnecessary data in API responses and improving request efficiency.

SDKs now validate section_filter parameters against allowed keys and value types, preventing typos and invalid configurations from causing unexpected behavior during scraping operations.

Hero image detection now only applies to the primary carousel container, preventing every image in nested carousels from being incorrectly tagged as hero content.

Navigation, header, footer, and aside elements are now stripped from extracted text after Readability cleaning, resulting in cleaner content without residual boilerplate elements.

Commas inside URLs in srcset attributes are now preserved correctly, handling Cloudinary transforms and Shopify query parameters that were previously split incorrectly.

Scroll_to_load functionality now works seamlessly with render_js set to auto, providing more flexibility for scraping sites with dynamic content loading.

Image source resolution now handles common lazy-loading patterns including data attributes and srcset, improving image extraction from sites using various lazy-loading techniques.

Python and Node SDKs now support the section_filter parameter, keeping SDK functionality in sync with the API's SectionFilter model for more precise content extraction.

Your workspace settings now include an Activity tab showing a full audit trail of team actions — invitations, role changes, and configuration updates. Stay informed about everything happening in your workspace.

View workspace usage statistics at a glance with the new stats card. You can also resend invitations, leave workspaces, and set custom avatar URLs directly from settings.

Share promo codes via URL — signed-out users are guided through signup with the code pre-filled, and the deposit page automatically applies it. No more copy-pasting promo codes.

New users who receive a reduced welcome bonus now see a clear modal explaining why, with an option to unlock the full bonus. No more confusion about varying signup credit amounts.

When a promo code is active, the deposit page now shows the discount clearly and pre-fills the code from URL parameters. The apply button no longer triggers errors from browser event objects.

Plus 20 internal improvements including homepage visual polish, SEO structured data enhancements, and blog reliability fixes.

Fixed several issues with workspace switching — balance now refreshes correctly, dialogs close properly before secondary operations, and tab state no longer resets unexpectedly when switching contexts.

API Keys and Playground tables no longer truncate columns on smaller screens. Content is fully visible without horizontal scrolling cutting off important data.

Added per-IP and per-email rate limiting to login, OAuth, and verification endpoints. Verification codes are now hashed before storage, and brute-force protection with progressive lockout is active on all auth routes.

API keys are now rotated on each OAuth token exchange instead of re-exposing the same key. Localhost redirect URIs are blocked in production, and re-verification emails are sent after email changes.

Revoking a session now properly invalidates the associated JWT token, preventing continued access with stale credentials.

New users now get a streamlined onboarding flow with one-touch API key creation and a guided playground tutorial. Get from signup to your first scrape faster than ever.

Receive helpful emails at key moments — onboarding tips after signup, integration guides if you're using the playground but haven't connected via API, and re-engagement nudges. All emails include one-click unsubscribe.

The dashboard now highlights features you haven't tried yet. See contextual cards for schedules, monitors, and API integration with code snippets ready to copy.

All platform emails now include HMAC-signed unsubscribe links and a dedicated unsubscribe page, ensuring full CAN-SPAM compliance.

The pricing page now includes a detailed comparison table showing how AlterLab stacks up against alternatives on features, pricing, and capabilities.

Ten documentation pages now include interactive screenshots showing real dashboard UI, making it easier to follow along with guides and tutorials.

The entire platform now uses consistent 'requests' terminology instead of 'credits', making pricing and usage clearer. All pages, components, and docs have been updated.

Standardized balance formatting, latency display, and error states across the entire dashboard. Stat cards use smart formatting, and billing shows consistent pricing everywhere.

Recent Activity now supports Load More pagination, the deposit success page has a countdown auto-redirect, and pricing displays are unified across all billing sections.

Plus 30 internal improvements including mobile sidebar fixes, SEO title rewrites, cookie consent positioning, webhook navigation, and blog cover image enhancements.

Fixed an issue where the usage page could get permanently stuck on a skeleton loading state. The page now loads reliably every time.

Fixed inaccurate competitor pricing claims across comparison and marketing pages. All pricing data now reflects current published rates.

The signin page now shows email/password form and Microsoft OAuth. Check-email rate limit raised to 10/hour with proper 429 error surfacing. OAuth errors redirect with toast notifications.

New /vs pages let you compare AlterLab against specific alternatives side-by-side, with feature matrices, pricing calculators, and migration guides. Find the right tool for your use case.

New step-by-step tutorials covering real-time monitoring dashboards, WebSocket updates, AI agent and MCP integration, multi-page crawling, price monitoring pipelines, and cloud storage export.

Dedicated migration guides help you switch from ScraperAPI, ScrapingBee, and Apify with code examples showing equivalent AlterLab API calls for each platform's features.

All interactive elements now meet the 44px minimum touch target size, making the platform easier to use on phones and tablets.

Python and Node.js section headers on the SDK documentation page are now clickable links, making it easier to share direct references to specific SDK sections.

Plus 12 internal improvements including CI permissions, accessibility attributes, blog CTA placement, and pricing page sticky navigation.

Demo rate limits now show a signup CTA instead of a generic error. Comparison pages include signup funnels, and OAuth errors redirect back to the originating page with a notification.

Fixed several dashboard elements that appeared interactive but did nothing when clicked. All clickable-looking elements now respond or have been restyled.

Fixed an issue where demo API routes could be accessed by unauthorized external requests. Demo endpoints now properly enforce access restrictions.

Scrape and crawl endpoints now enforce per-API-key rate limits. This protects your account from accidental overuse and ensures fair resource allocation across all users.

You can now choose between light, dark, or system theme in the dashboard. The new 3-way toggle automatically follows your OS preference when set to system.

The billing system has been fully migrated to pay-as-you-go. All references to legacy subscription plans have been removed, and the dashboard now shows balance-based account tiers throughout.

All transactional emails from AlterLab now include a reply-to address, so you can reply directly to any email you receive from us.

Fixed an issue in the playground where rapidly clicking the Run button could fire multiple simultaneous requests. The button is now debounced and navigating away aborts in-flight requests.

Fixed an issue where verification emails showed an empty name in the greeting. Emails now use a proper placeholder when no name is available.

The batch scraping interface has been completely redesigned with a cleaner layout, real-time SSE progress streaming, content preview tabs, and a full result viewer. You can now clone batches, re-run failed items, and import URLs from CSV/TSV/JSON files.

You can now save and load batch configuration templates for repeated scraping tasks. A new analytics dashboard shows success rates, cost trends, and domain breakdown across your batch history.

Export scrape results directly to your cloud storage. Configure S3, GCS, or Azure connections in the new Storage Integrations settings page, then attach them to batch and schedule jobs.

A new Monitoring page lets you track changes on web pages over time. Set up monitors to detect when page content changes and get notified of differences.

You can now pause, resume, or delete multiple schedules at once. A new analytics dashboard shows schedule health rankings and credit cost forecasts. Search, filter, sort, and toggle between list and grid views.

You can now manually trigger a scheduled scrape with the new 'Run Now' button, without waiting for the next cron interval.

You can now clone any existing schedule or batch configuration with one click, making it easy to create variations of your scraping setups.

Batch and schedule pages now show an itemized cost calculator so you can estimate costs before running jobs.

You can now delete your account from the Settings page. A new danger zone section provides the option with clear confirmation steps.

You can now rename your API keys for better organization and regenerate them if compromised, without deleting and recreating.

A new profile tab in Settings lets you update your name and other profile information directly from the dashboard.

A new terminal component in the dashboard lets you interact with the API using CLI-style commands for jobs, stats, analysis, transactions, and data export.

Webhooks now automatically retry with exponential backoff on delivery failure. A delivery log shows the status of each attempt.

Fixed an issue where the password change page was inaccessible due to missing API routes. Password management now works correctly.

Fixed an issue where the API key list endpoint returned full key values. Keys are now properly masked in list responses.

Fixed several display issues with balance and billing: thousand separators now appear on all balance displays, sub-cent precision is hidden when zero, and deposit validation works correctly on the client side.

Fixed an issue where the playground page had horizontal overflow on mobile devices, making the response panel inaccessible.

Fixed the contact form being hidden on mobile viewports. The form is now fully accessible on all screen sizes.

Fixed an issue where some OAuth users experienced a sign-in loop caused by a database table mismatch. OAuth login now works reliably.

Fixed spend counter drift that could cause inaccurate usage reporting and billing sync timeouts.

You can now crawl entire websites with the new POST /v1/crawl endpoint. Progressive depth crawling discovers and scrapes pages automatically, respecting robots.txt. Supports up to 100,000 pages and 50 levels of depth, with billing per page.

Both the Python and Node.js SDKs now include crawl methods. Start a crawl, check status, and retrieve results programmatically with the same familiar SDK interface.

The playground now supports crawl mode with a visual config panel, depth slider, and animated multi-page results. The homepage demo shows live page discovery in action.

Crawl costs appear in your usage breakdown and transaction history. The crawl status page shows per-page cost breakdowns, session totals, and automatic refunds for failed pages.

A new visual workflow editor lets you build scraping automations on a drag-and-drop React Flow canvas. Connect scrape, HTTP request, webhook, email, and download nodes to create complex workflows.

A curated gallery of workflow templates helps you get started quickly. Browse pre-built templates and customize them for your use case.

Monitor your workflow executions in real-time with the run dashboard. View execution history, retry failed runs, and track progress.

You can now reset your password via email. The new forgot password page and backend flow lets you recover access to your account securely.

A new benchmarks page shows real performance data and comparisons, so you can see how AlterLab performs across different website types and protection levels.

Documentation pages are now served as markdown for AI agent consumption, along with a public OpenAPI spec and AI plugin manifest. This makes it easier for LLM-based tools to work with the AlterLab API.

Fixed an issue where usage logs paginated by raw database rows instead of top-level entries, causing confusing page counts when crawl jobs were present.

This release includes internal improvements for better reliability and performance.

The Crawl API is now live with POST/GET/DELETE endpoints, progressive depth crawling, and full playground support. Crawl results include per-page cost breakdowns and automatic refunds for failures.

Both Python and Node.js SDKs now include crawl methods. Start crawls, poll status, and retrieve results programmatically.

Crawl costs now appear in your usage breakdown and transaction history. The crawl status page shows tier breakdowns and session cost tracking.

You can now reset your password via a secure email flow. The forgot password link on the sign-in page walks you through the recovery process.

Export scrape results directly to S3, GCS, or Azure. Configure storage integrations in Settings and attach them to batch and schedule jobs.

You can now set spending limits per API key and at the account level. Scheduled and batch scrapes enforce these limits, and credits are automatically refunded when jobs fail.

Tier cards on the billing page are now interactive, making it easier to understand and compare what each tier offers.

Reduced initial page load time by deferring below-fold JavaScript and heavy 3D animations. Dashboard skeleton loaders replace spinners for smoother perceived performance.

Fixed an issue where some users experienced an infinite sign-in loop when using Google OAuth due to a database table mismatch.

The balance area in the dashboard header is now clickable and links directly to the billing page.

Crawl limits have been raised to 100,000 pages and 50 levels of depth, supporting larger site crawls.

Scrape as your logged-in self. Pass your own session cookies or custom auth headers to access member pricing, paywalled content, private communities, and internal dashboards. Zero credential storage — cookies are used for the request only and immediately discarded.

New 'cookies' parameter accepts cookie strings or key-value objects. Works with all tiers including JS rendering and anti-bot bypass. No surcharge for authenticated requests.

Pass Bearer tokens, OAuth headers, or any custom authentication headers via the 'extra_headers' parameter. Perfect for scraping authenticated API endpoints and web apps behind SSO.

Session data is held in memory only, encrypted via TLS 1.3, never written to disk or logs, and discarded immediately after the request completes. Your credentials stay yours.

Tier cards on the billing page are now interactive, making it easier to compare features and costs across scraping tiers.

Reduced initial page load by deferring below-fold JavaScript and heavy 3D animations. Dashboard pages now load noticeably faster.

Scraping is now more reliable with better handling of large HTML pages, faster dead proxy detection, and improved timeout management for browser-based scraping.

The balance area in the dashboard header is now a clickable link that takes you directly to the billing page.

The platform's content analysis engine has been refined to better handle small but legitimate web pages. This optimization prevents unnecessary resource escalation, resulting in significantly faster response times and lower credit costs for lightweight targets.

Plus 8 internal improvements for better reliability and performance.

We identified and resolved an issue that caused scraping requests to fail with service errors during processing. This fix ensures that your integration remains stable and that data is delivered reliably across all request volumes.

We have implemented advanced risk assessment protocols for all checkout and deposit activities to safeguard your account against unauthorized transactions. This update adds a robust layer of protection to your billing workflow while ensuring a smooth payment experience.

You can now submit thousands of URLs in a single POST /v1/batch request. Track progress, get webhook notifications on completion, and view itemized billing for each URL.

Set up recurring scrape jobs using cron expressions. Schedules run automatically and apply your BYOP discount when configured.

New dashboard pages for managing batch jobs and schedules, with progress tracking, error details, and usage breakdowns.

A new DPA page is now available for enterprise customers who need a formal data processing agreement.

Fixed an issue where the usage chart on the dashboard was showing a placeholder instead of real data.

Failed scrape requests now appear in your detailed usage logs, giving you full visibility into what went wrong.

Internal performance optimizations to improve scraping reliability and reduce resource usage under high load.

Fixed an issue where signing in with Google OAuth could crash due to a logging error in the fingerprint service.

Updated extraction selectors for Amazon product pages to correctly capture coupon and promotional offer data.

New compliance layer screens signups against OFAC sanctions lists and applies geo-IP restrictions for prohibited regions.

The usage page now shows your current balance prominently and removes misleading hover effects from non-interactive elements.