📸 Website Screenshot Crawler 🌐

Capture high-quality screenshots of any website with advanced scrolling capabilities and cookie support. Perfect for web monitoring, documentation, testing, and content archival.

• Full-Page Screenshots: Capture entire webpage length, not just viewport
• Custom Viewport: Set any browser window dimensions
• High-Quality PNG: Lossless image format for professional results
• Smart Wait Conditions: Multiple options for page load completion

• Cookie Support: Import cookies for authenticated sessions
• Persistent Sessions: Maintain login states across captures
• Paywall Bypass: Access restricted content with proper authentication
• Custom Headers: Support for various authentication methods

• Network Idle Detection: Multiple wait conditions for page loading
• Timeout Control: Configurable page load timeouts
• Resource Management: Efficient memory usage with headless browsing

This actor uses a 30-second interval charging system for optimal cost efficiency:

Plan your budget with precision! Use our interactive cost calculator to estimate your exact costs before running the actor:

🔗 Launch Cost Calculator

Features:

• ⚡ Real-time calculations as you adjust parameters
• 📊 Visual cost breakdown by component (initialization, memory, screenshots)
• 🎯 Scenario planning with different configurations
• 💡 Cost optimization suggestions for better efficiency
• 📱 Mobile-friendly interface for on-the-go planning

1. Actor Initialization - One-time startup fee
2. Memory Usage - Based on memory allocation and runtime
3. Screenshot Capture - Per successful screenshot

• Every 30 seconds of runtime = 1 interval
• 1 minute = 2 intervals | 1 hour = 120 intervals
• Total operations = Memory (GB) × Number of intervals

• Scenario: 1 screenshot, 1GB memory, 30 seconds runtime
• Calculation:
  • Initialization: $0.05
  • Memory: 1GB × 1 interval × $0.0033 = $0.0033
  • Screenshots: 1 × $0.01 = $0.01
• Total: $0.0633 (FREE tier)

• Scenario: 10 screenshots, 2GB memory, 5 minutes runtime
• Calculation:
  • Initialization: $0.05
  • Memory: 2GB × 10 intervals × $0.0033 = $0.066
  • Screenshots: 10 × $0.01 = $0.10
• Total: $0.216 (FREE tier)

• Scenario: 50 screenshots, 4GB memory, 30 minutes runtime
• Calculation:
  • Initialization: $0.05
  • Memory: 4GB × 60 intervals × $0.0033 = $0.792
  • Screenshots: 50 × $0.01 = $0.50
• Total: $1.342 (FREE tier)

1. Choose Right Memory: Use minimum required memory allocation
2. Optimize Runtime: Reduce unnecessary wait times
3. Batch Processing: Process multiple URLs in single run
4. Upgrade Tier: Higher tiers offer significant savings for heavy usage
5. Use the Calculator: Plan your runs with our cost calculator tool

Your Apify dashboard will show:

• Operations count: Memory (GB) × 30-second intervals
• Example: 2GB memory running for 5 minutes = 2 × 10 = 20 operations
• Cost calculation: 20 operations × $0.0033 = $0.066 for memory usage

{
  "link_urls": [
    { "url": "https://example.com" }
  ],
  "fullPage": true
}

{
  "link_urls": [
    { "url": "https://example.com" },
    { "url": "https://github.com" },
    { "url": "https://stackoverflow.com" }
  ],
  "fullPage": false,
  "waitUntil": "domcontentloaded"
}

{
  "link_urls": [
    { "url": "https://example.com" }
  ],
  "window_Width": 1366,
  "window_Height": 768,
  "waitUntil": "networkidle0"
}

{
  "link_urls": [
    { "url": "https://secure-site.com/dashboard" }
  ],
  "cookies": [
    {
      "name": "session_token",
      "value": "abc123xyz",
      "domain": ".secure-site.com"
    }
  ],
  "fullPage": true
}

Note: Scrolling features have been removed from this version. Use fullPage: true to capture the entire page height.

• load: Wait until all resources are loaded (slower but complete)
• domcontentloaded: Wait until HTML is parsed (faster, recommended for complex sites)
• networkidle0: Wait until no network connections (may timeout on complex sites)
• networkidle2: Wait until minimal network connections (may timeout on complex sites)

Each successful capture returns:

{
  "screenshot_url": "https://api.apify.com/v2/key-value-stores/QNNAmIXDEDePpHEd5/records/hrp8rcmv12jgllxf.png",
  "linkUrl": "https://www.medium.com"
}

• screenshot_url: Direct download link to the captured PNG image
• linkUrl: Original URL that was captured (extracted from the URL object)
• File Format: PNG with random 16-character filename
• Storage: Apify Key-Value Store with permanent URLs

• Website Monitoring: Track visual changes and updates
• Competitor Analysis: Regular captures of competitor pages
• Documentation: Create visual records of web states
• Archival: Preserve webpage appearances over time

• Responsive Testing: Verify layouts at different viewport sizes
• Cross-Browser Testing: Ensure consistent appearance
• Bug Documentation: Capture error states and issues
• CI/CD Integration: Automated screenshot testing

• Tutorial Creation: Generate step-by-step visual guides
• Academic Research: Capture web-based data and layouts
• Social Media: Create engaging visual content
• Portfolio: Showcase web development projects

• Price Monitoring: Track product pages and pricing
• Ad Campaign Tracking: Monitor landing pages
• A/B Testing: Compare different page versions
• SEO Analysis: Document search result pages

{
  "link_urls": [
    { "url": "https://example.com" }
  ],
  "window_Width": 2560,
  "window_Height": 1440,
  "fullPage": true,
  "waitUntil": "networkidle0"
}

{
  "link_urls": [
    { "url": "https://fast-site.com" }
  ],
  "fullPage": false,
  "waitUntil": "domcontentloaded"
}

{
  "link_urls": [
    { "url": "https://mobile-site.com" }
  ],
  "window_Width": 375,
  "window_Height": 812,
  "fullPage": true
}

{
  "link_urls": [
    { "url": "https://dashboard.example.com" }
  ],
  "cookies": [
    {
      "name": "auth_token",
      "value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
      "domain": ".example.com",
      "path": "/",
      "secure": true,
      "httpOnly": true
    }
  ],
  "waitUntil": "networkidle0"
}

• Engine: Pyppeteer (Chrome/Chromium)
• Mode: Headless for optimal performance
• Security: Sandbox disabled for containerized environments
• Memory: Optimized shared memory usage
• Images: Optional image loading for faster processing

• Async Processing: Non-blocking operations for multiple URLs
• Memory Management: Efficient resource cleanup
• Network Optimization: Configurable network idle detection
• Error Handling: Robust error recovery and logging

• Naming: Random 16-character filenames to prevent conflicts
• Storage: Apify Key-Value Store with permanent URLs
• Format: PNG for lossless quality
• Cleanup: Automatic temporary file removal

1. Cost Planning: Use our cost calculator to estimate expenses
2. Input Configuration: Set your parameters using JSON or the visual editor
3. Execute: Run the actor and monitor progress
4. Results: Access screenshots via the generated dataset
5. Download: Use the provided URLs to download images

• Apify API: Programmatic access via REST API
• Webhooks: Automated notifications on completion
• Scheduling: Run captures at regular intervals
• Zapier Integration: Connect with other tools and services

Screenshots are blank or incomplete?

• Try waitUntil: "networkidle2" for slower sites
• Enable fullPage: true for complete page capture
• Check if site blocks automation tools
• Verify URL accessibility

Page won't load properly?

• Increase timeout by using different waitUntil conditions
• Verify URL accessibility
• Check for required cookies/authentication
• Try waitUntil: "domcontentloaded" for faster loading

Cookie authentication failing?

• Verify cookie format and values
• Check domain and path settings
• Ensure cookies are not expired
• Test with browser developer tools first

The actor validates all input parameters according to the JSON Schema specification. Invalid inputs will result in clear error messages.

Results are stored in Apify Dataset with consistent structure:

• URL: screenshot_url for direct image access
• Source: linkUrl for reference tracking
• Storage: Permanent Key-Value Store links

• Network Errors: Automatic retry mechanisms
• Timeout Handling: Graceful failure with logging
• Invalid URLs: Clear error messages
• Memory Issues: Efficient cleanup and recovery

1. Plan Costs First: Use our cost calculator to optimize your budget
2. Test First: Start with default settings and adjust gradually
3. Monitor Performance: Balance quality vs speed based on needs
4. Handle Failures: Implement retry logic for critical captures
5. Optimize Timing: Adjust Sleep and delay for your target sites
6. Use Appropriate Viewports: Match your analysis requirements

• Use domcontentloaded for fast, static sites (default)
• Use networkidle0 for dynamic, interactive sites
• Use fullPage: false for faster viewport-only captures
• Monitor memory usage for large batch operations

• Store cookies securely when using authentication
• Validate URLs before processing
• Respect robots.txt and rate limits
• Use proper authentication methods
• Monitor for sensitive data in screenshots

• Simple Page: ~5-10 seconds per screenshot
• Complex Page: ~15-30 seconds with scrolling
• Full Page: Additional 2-5 seconds for scrolling
• Authenticated: +2-3 seconds for cookie setup

• Memory: ~50-100MB per browser instance
• CPU: Moderate usage during capture
• Network: Depends on page size and resources
• Storage: PNG files typically 100KB-5MB

• 📧 Email: [email protected]
• 🐙 GitHub: FlowExtractAPI
• 🐦 Twitter: @FlowExtractAPI
• 🔧 Apify: FlowExtract API

• Review this documentation thoroughly
• Check common issues and solutions
• Test with simple examples first
• Monitor actor logs for detailed error information

• Regular updates for browser compatibility
• Performance optimizations based on usage patterns
• New features based on user feedback
• Security updates and bug fixes