Puppeteer on Lambda vs Screenshot API: Cost Breakdown at Every Scale
At under 50,000 screenshots per month, a screenshot API is cheaper than running Puppeteer on AWS Lambda once you factor in engineering time, cold start mitigation, and storage. Above 100K, Lambda's raw compute cost drops lower, but you're still spending 4+ hours per month maintaining Chrome in a serverless environment. Here's the full math at every scale tier, with SnapRender and ScreenshotOne as API baselines.
The Costs Nobody Includes in Lambda Estimates
Every Lambda cost estimate I've seen online calculates compute and invocations, then stops. That's maybe 30% of the real cost. Here's what actually goes on the bill for a puppeteer screenshot docker lambda setup.
AWS line items:
- Lambda compute (GB-seconds)
- Lambda invocations
- API Gateway requests
- Data transfer out (screenshots are images, they add up)
- S3 storage (you need to put the images somewhere)
- CloudWatch Logs (Chrome is verbose)
- Provisioned concurrency (if you care about cold starts)
Hidden costs:
- Engineering time to build and maintain
- Cold start impact on user experience (8-15 seconds on first request)
- Debugging time when Chrome updates break things
- Monitoring and alerting setup
Let me put numbers to all of these.
Lambda Cost Assumptions
These assumptions are consistent across every tier in the comparison:
| Parameter | Value | Notes |
|---|---|---|
| Memory | 2048MB | Minimum reliable config for Chromium |
| Average execution time | 8 seconds | Includes warm and cold starts |
| Screenshot size (avg) | 500KB | Typical full-viewport PNG |
| Region | us-east-1 | Cheapest US region |
| Provisioned concurrency | 3 instances | Keeps cold starts manageable |
| S3 storage | Standard tier | Screenshots stored for 30 days |
| API Gateway | REST API | $3.50 per million requests |
Lambda pricing (us-east-1, March 2026):
- Compute: $0.0000166667 per GB-second
- Invocations: $0.20 per million
- Provisioned concurrency: $0.0000041667 per GB-second
- Data transfer: $0.09/GB (first 10TB)
Provisioned concurrency cost (3 instances, always on):
- 3 x 2 GB x 2,592,000 seconds/month x $0.0000041667 = $64.80/month fixed
The Comparison Table
| Monthly Screenshots | Lambda (no provisioned) | Lambda (with provisioned) | SnapRender | ScreenshotOne |
|---|---|---|---|---|
| 500 | $1.64 | $66.44 | $0 (Free) | $0 (Free) |
| 2,000 | $4.06 | $68.86 | $9 (Starter) | $29 (Starter) |
| 5,000 | $8.91 | $73.71 | $29 (Growth) | $29 (Starter) |
| 10,000 | $16.33 | $81.13 | $29 (Growth) | $79 (Growth) |
| 25,000 | $38.58 | $103.38 | $79 (Business) | $79 (Growth) |
| 50,000 | $75.66 | $140.46 | $79 (Business) | $199 (Pro) |
| 100,000 | $149.82 | $214.62 | $199 (Scale) | $249 (Business) |
| 200,000 | $298.14 | $362.94 | $199 (Scale) | $499 (Enterprise) |
How I Calculated Lambda Costs
Here's the breakdown for 10,000 screenshots (the other tiers follow the same formula):
| Component | Calculation | Cost |
|---|---|---|
| Compute | 10,000 x 8s x 2GB x $0.0000166667/GB-s | $2.67 |
| Invocations | 10,000 x $0.20/1M | $0.002 |
| API Gateway | 10,000 x $3.50/1M | $0.04 |
| Data transfer | 10,000 x 500KB = 5GB x $0.09/GB | $0.45 |
| S3 storage (30 days) | 5GB x $0.023/GB | $0.12 |
| S3 PUT requests | 10,000 x $0.005/1K | $0.05 |
| CloudWatch Logs | ~10MB x $0.50/GB | $0.01 |
| Subtotal (no provisioned) | $3.34 | |
| Warm-up pings (if no provisioned) | 8,640 invocations x minimal cost | $0.15 |
| Subtotal with warm-up only | $3.49 | |
| Provisioned concurrency (3 instances) | 3 x 2GB x 2,592,000s x $0.0000041667 | $64.80 |
| Subtotal with provisioned | $68.14 |
Note: the table above rounds slightly differently due to warm-up pings and rounding at each tier. The numbers are close enough for decision-making.
But Wait: Those Lambda Numbers Look Cheap
At 10,000 screenshots, Lambda without provisioned concurrency costs $3.49. SnapRender costs $29. Lambda wins, right?
Not so fast. Those $3.49 come with:
Cold starts of 8-15 seconds on the first request after idle time. If your users are waiting for these screenshots in a UI, that's unacceptable. You either eat the cold start penalty or pay $64.80/month for provisioned concurrency. With provisioned concurrency, Lambda costs $68.14 vs SnapRender's $29.
No caching. Every request runs Chromium, navigates the page, takes the screenshot. SnapRender caches results with configurable TTL and serves cached responses in under 200ms. If 30% of your requests are for the same URLs (common in link preview or social card generation), you're paying for 10,000 Lambda invocations when an API handles 7,000 of them from cache.
No built-in features. Ad blocking, cookie banner removal, dark mode, device emulation, custom viewports, selectors to hide or click? With Lambda, you build each of these yourself. With SnapRender, they're query parameters.
The Total Cost of Ownership
This is where the comparison gets honest. Lambda doesn't maintain itself.
Initial setup: 8-16 hours for a production-ready deployment (handler code, SAM/CDK template, Docker if needed, error handling, S3 integration, monitoring, CI/CD).
Monthly maintenance: 2-4 hours. Chrome updates, Lambda runtime updates, debugging failed screenshots, adjusting memory/timeout for edge cases, monitoring CloudWatch for errors.
Incident response: 2-4 hours per incident. Chrome crashes from memory pressure, /tmp filling up, new websites breaking your rendering pipeline.
At $75/hour (a conservative mid-career dev rate), let's add engineering time:
| Monthly Screenshots | Lambda (provisioned) | + Engineering (4hr/mo) | SnapRender | ScreenshotOne |
|---|---|---|---|---|
| 500 | $66.44 | $366.44 | $0 | $0 |
| 2,000 | $68.86 | $368.86 | $9 | $29 |
| 5,000 | $73.71 | $373.71 | $29 | $29 |
| 10,000 | $81.13 | $381.13 | $29 | $79 |
| 25,000 | $103.38 | $403.38 | $79 | $79 |
| 50,000 | $140.46 | $440.46 | $79 | $199 |
| 100,000 | $214.62 | $514.62 | $199 | $249 |
| 200,000 | $362.94 | $662.94 | $199 | $499 |
Even at 200,000 screenshots per month, SnapRender's Scale plan at $199 costs 70% less than Lambda's total cost of ownership. For an even deeper look at self-hosting economics, see The Real Cost of Self-Hosting Screenshots.
"But my team already knows Lambda, maintenance is minimal." Fair. Reduce the engineering estimate to 2 hours. That's still $150/month on top of AWS costs. Lambda with provisioned concurrency at 10K screenshots: $81 + $150 = $231 vs SnapRender's $29.
Feature Comparison
Cost isn't everything. Here's what you get (and don't get) with each approach:
| Feature | Lambda + Puppeteer | SnapRender | ScreenshotOne |
|---|---|---|---|
| PNG/JPEG/WebP | Build it | Yes | Yes |
| PDF capture | Build it | Yes | Yes |
| Full-page screenshots | Build it | Yes (32,768px max) | Yes |
| Device emulation | Build it | Query parameter | Query parameter |
| Ad blocking | Build it | Query parameter | Paid add-on |
| Cookie banner removal | Build it | Query parameter | No |
| Dark mode | Build it | Query parameter | No |
| Click selector before capture | Build it | Query parameter | No |
| Hide selectors | Build it | Query parameter | Yes |
| Response caching | Build it (Redis/S3) | Built-in, configurable TTL | Built-in |
| Cached response time | Depends on your cache layer | Under 200ms | Varies |
| Custom JavaScript injection | Yes (full control) | No | Paid add-on |
| SDKs | Build your own client | npm + PyPI + MCP server | npm + PyPI |
| Feature gating by plan | N/A | None (all features, all plans) | Some features paid |
| SLA | Your own uptime | Managed | Managed |
The "build it" column is the key differentiator. Every feature you add to your Lambda function is code you maintain. SnapRender's approach of exposing everything as query parameters with no feature gating means the $29/month Growth plan gives you the same capabilities as the $199 Scale plan, just fewer screenshots. For a full comparison of how different APIs stack up on pricing, check Screenshot API Pricing Compared.
When Lambda Wins
I'm not going to pretend Lambda never makes sense. Here are the legitimate use cases:
Custom browser automation. You need to log into a site, navigate through a multi-step flow, then capture a specific state. No screenshot API handles authenticated sessions with complex interaction sequences.
Self-hosted data requirements. Compliance rules prevent you from sending URLs to a third-party service. Government, healthcare, financial services sometimes have this constraint.
Extreme volume with simple requirements. At 500K+ screenshots per month, with homogeneous URLs (same site, same structure), a well-tuned Lambda function with no provisioned concurrency can be cheaper. But you need dedicated DevOps time.
Integration with existing AWS pipeline. If screenshots are part of a larger Step Functions workflow that already runs in AWS, adding a Lambda step avoids cross-service latency.
When SnapRender Wins
For the majority of puppeteer screenshot docker lambda use cases I've seen, the actual need is: "I have a URL, I want an image."
Link previews and social cards. High cache hit rate, response time matters, users are waiting. SnapRender's caching handles this perfectly.
Automated reporting. Capture dashboards as PDFs on a schedule. Fire a GET request, get a PDF. No infrastructure.
Content thumbnails. E-commerce, CMS platforms, portfolio sites. Hundreds of URLs, each captured once, cached for days. The Growth plan at $29 handles 10,000 of these.
Any team without dedicated DevOps. If nobody on your team wants to own a Chrome-in-Lambda deployment, don't build one. The $29-79/month for an API is cheaper than a single debugging session.
Quick Decision Framework
Ask yourself three questions:
-
Do I need to interact with the page beyond navigation? (Login, click through flows, run custom JS)
- Yes: Lambda or self-hosted Puppeteer
- No: Screenshot API
-
Do I need screenshots in under 1 second consistently?
- Yes: SnapRender (under 200ms cached) or Lambda with provisioned concurrency ($65+/month)
- No: Lambda without provisioned concurrency works, but expect 8-15s cold starts
-
How many screenshots per month?
- Under 500: SnapRender Free tier ($0)
- 500-50K: SnapRender ($9-79) beats Lambda TCO
- 50K-200K: SnapRender Scale ($199) still beats Lambda TCO when you count engineering time
- 200K+: Lambda becomes competitive on raw cost. Factor in your actual maintenance hours.
The Bottom Line
Lambda's compute costs look attractive in isolation. At 10K screenshots, $3.49 vs $29 seems like an easy win for Lambda. But compute cost is a fraction of what you actually pay. Add provisioned concurrency to fix cold starts ($65/month), then add even modest engineering time ($150-300/month), and Lambda costs 5-10x more than SnapRender at the same volume.
The breakeven point where Lambda's raw cost advantage overcomes its maintenance overhead is somewhere north of 200K screenshots per month, and only if you already have DevOps infrastructure and Chrome expertise on your team.
For most teams, the right answer is: use SnapRender, ship your feature today, and spend your engineering hours on your actual product. The complete API guide has everything you need to get started, or check From Timeout Hell to 200ms for another team's migration story.